1. 逻辑回归与交叉熵损失函数基础

逻辑回归是机器学习中最基础的分类算法之一，尽管名字中带有"回归"，但它实际上解决的是二分类问题。在PyTorch中实现逻辑回归训练，核心在于正确理解交叉熵损失函数的数学原理及其实现方式。

逻辑回归模型的输出经过sigmoid函数转换后，表示样本属于正类的概率。数学表达式为： P(y=1|x) = σ(w^T x + b) = 1/(1+e^(-(w^T x + b)))

交叉熵损失函数衡量的是模型预测概率分布与真实分布的差异。对于二分类问题，其定义为： L = -[y log(p) + (1-y)log(1-p)]

这个损失函数有几个重要特性：

1. 当预测概率p接近真实标签y时，损失趋近于0
2. 当预测与真实标签相反时，损失会趋近于无穷大
3. 对错误预测的惩罚随着错误程度的增加而呈对数增长

注意：在实际实现中，我们通常使用PyTorch内置的BCELoss（Binary Cross Entropy Loss）或BCEWithLogitsLoss（结合了sigmoid和BCE的版本），后者在数值稳定性上表现更好。

2. PyTorch实现逻辑回归的完整流程

2.1 数据准备与预处理

首先需要准备适合逻辑回归处理的数据。逻辑回归假设数据是线性可分的（在特征空间中可以找到一个超平面将两类分开），因此对于非线性问题需要考虑特征工程。

import torch
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 生成模拟数据
X, y = make_classification(n_samples=1000, n_features=10, n_classes=2, random_state=42)

# 转换为PyTorch张量并划分训练集/测试集
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.float32).reshape(-1, 1)  # 需要reshape为(n_samples, 1)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

2.2 模型定义

在PyTorch中定义逻辑回归模型非常简单，因为它本质上就是一个线性层加上sigmoid激活函数。

import torch.nn as nn

class LogisticRegression(nn.Module):
    def __init__(self, input_dim):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_dim, 1)
        
    def forward(self, x):
        return torch.sigmoid(self.linear(x))

2.3 训练循环实现

完整的训练循环包括前向传播、损失计算、反向传播和参数更新四个主要步骤。

# 初始化模型、损失函数和优化器
model = LogisticRegression(X_train.shape[1])
criterion = nn.BCELoss()  # 二分类交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# 训练参数
n_epochs = 1000

for epoch in range(n_epochs):
    # 前向传播
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    # 每100轮打印一次损失
    if (epoch+1) % 100 == 0:
        print(f'Epoch [{epoch+1}/{n_epochs}], Loss: {loss.item():.4f}')

3. 关键实现细节与优化技巧

3.1 使用BCEWithLogitsLoss的优势

在实践中，我们更推荐使用BCEWithLogitsLoss而不是手动应用sigmoid+BCELoss的组合。主要原因包括：

1. 数值稳定性更好：直接在logits空间计算损失，避免了sigmoid函数在极端值时的数值不稳定问题
2. 计算效率更高：合并了两个操作，减少了中间变量的存储
3. 内置了防止数值溢出的保护机制

修改后的模型和训练代码如下：

class LogisticRegression(nn.Module):
    def __init__(self, input_dim):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_dim, 1)
        
    def forward(self, x):
        return self.linear(x)  # 不再应用sigmoid

# 使用BCEWithLogitsLoss
criterion = nn.BCEWithLogitsLoss()

3.2 学习率选择与优化器配置

逻辑回归对学习率比较敏感，过大容易震荡，过小收敛缓慢。一些实用建议：

1. 初始学习率可以尝试0.1、0.01等常见值
2. 使用学习率调度器动态调整学习率
3. 考虑使用带动量的优化器如Adam

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.1)

3.3 特征标准化的重要性

逻辑回归的性能很大程度上依赖于特征尺度。对特征进行标准化通常能显著提高模型性能和训练稳定性。

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

4. 模型评估与性能分析

4.1 评估指标实现

对于二分类问题，常用的评估指标包括准确率、精确率、召回率、F1分数和AUC-ROC等。

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

def evaluate(model, X, y):
    with torch.no_grad():
        outputs = model(X)
        preds = (outputs > 0.5).float()
        
        acc = accuracy_score(y, preds)
        prec = precision_score(y, preds)
        rec = recall_score(y, preds)
        f1 = f1_score(y, preds)
        auc = roc_auc_score(y, outputs.numpy())
        
        print(f'Accuracy: {acc:.4f}, Precision: {prec:.4f}')
        print(f'Recall: {rec:.4f}, F1: {f1:.4f}, AUC: {auc:.4f}')

print("Training set performance:")
evaluate(model, X_train, y_train)

print("\nTest set performance:")
evaluate(model, X_test, y_test)

4.2 决策边界可视化

对于二维特征的情况，我们可以可视化模型的决策边界，直观理解模型的分类行为。

import matplotlib.pyplot as plt
import numpy as np

# 生成二维数据示例
X_2d, y_2d = make_classification(n_samples=1000, n_features=2, n_classes=2, random_state=42)
X_2d = torch.tensor(X_2d, dtype=torch.float32)
y_2d = torch.tensor(y_2d, dtype=torch.float32).reshape(-1, 1)

# 训练二维模型
model_2d = LogisticRegression(2)
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.SGD(model_2d.parameters(), lr=0.1)

for epoch in range(1000):
    outputs = model_2d(X_2d)
    loss = criterion(outputs, y_2d)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 可视化
def plot_decision_boundary(model, X, y):
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
                         np.arange(y_min, y_max, 0.1))
    
    Z = model(torch.tensor(np.c_[xx.ravel(), yy.ravel()], dtype=torch.float32))
    Z = (Z > 0.5).float().reshape(xx.shape)
    
    plt.contourf(xx, yy, Z, alpha=0.4)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')
    plt.title("Decision Boundary Visualization")
    plt.show()

plot_decision_boundary(model_2d, X_2d.numpy(), y_2d.numpy())

5. 常见问题与解决方案

5.1 损失不下降的可能原因

1. 学习率设置不当：尝试调整学习率大小
2. 特征尺度差异大：进行特征标准化
3. 模型过于简单：检查是否所有特征都已被正确使用
4. 数据标签不平衡：考虑类别权重或重采样

5.2 处理类别不平衡问题

对于不平衡数据集，可以通过以下方式调整：

1. 在损失函数中设置类别权重

pos_weight = torch.tensor([num_negative/num_positive])
criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)

2. 使用过采样/欠采样技术
3. 采用不同的分类阈值（而非默认的0.5）

5.3 数值稳定性问题

当使用普通BCELoss时，可能会遇到数值不稳定的情况。解决方案包括：

1. 使用BCEWithLogitsLoss代替
2. 在手动实现时对sigmoid输出进行裁剪

outputs = torch.clamp(outputs, 1e-7, 1-1e-7)  # 避免log(0)

6. 高级扩展与变体

6.1 多分类逻辑回归

虽然本文主要讨论二分类问题，但逻辑回归可以扩展到多分类场景（称为多项逻辑回归或softmax回归）。PyTorch实现时主要变化：

1. 输出维度变为类别数
2. 使用CrossEntropyLoss（已经包含softmax）
3. 不再需要sigmoid激活

class MultinomialLogisticRegression(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, output_dim)
        
    def forward(self, x):
        return self.linear(x)  # CrossEntropyLoss会自动应用softmax

# 使用时
criterion = nn.CrossEntropyLoss()

6.2 正则化技术应用

为了防止过拟合，可以在逻辑回归中加入L1或L2正则化：

1. 通过优化器的weight_decay参数实现L2正则化

optimizer = torch.optim.SGD(model.parameters(), lr=0.1, weight_decay=1e-4)

2. 手动实现L1正则化

l1_lambda = 0.001
l1_norm = sum(p.abs().sum() for p in model.parameters())
loss = criterion(outputs, y_train) + l1_lambda * l1_norm

6.3 与其他模型的结合

逻辑回归可以作为更复杂模型的组成部分，例如：

1. 作为神经网络的第一层或最后一层
2. 集成到图神经网络中处理节点分类任务
3. 与注意力机制结合处理序列数据