PyTorch实现逻辑回归：从原理到实战

1. 逻辑回归基础与PyTorch实现概览

逻辑回归是机器学习中最基础但极其重要的分类算法，尽管名字中带有"回归"，它实际上解决的是二分类问题。在PyTorch框架下实现逻辑回归，不仅能理解深度学习的基础构建块，还能掌握自定义模型的核心方法。

关键理解：逻辑回归本质是在线性回归的输出上套用sigmoid函数，将任意实数映射到(0,1)区间，解释为概率值。当概率>0.5时预测为正类，否则为负类。

1.1 为什么选择PyTorch实现

PyTorch的动态计算图特性使得模型开发和调试过程非常直观：

• 即时执行模式：操作结果立即可见，便于理解数据流动
• 自动微分系统：无需手动实现反向传播
• 模块化设计：nn.Module基类提供标准的模型封装方式
• GPU加速：只需简单.to(device)即可迁移计算设备

import torch import torch.nn as nn # 基础检查：验证环境配置 print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}")

2. 核心组件实现详解

2.1 Sigmoid函数原理与可视化

Sigmoid函数的数学表达式为： $$ \sigma(z) = \frac{1}{1+e^{-z}} $$

其特性包括：

• 将输入压缩到(0,1)区间
• 在z=0处斜率最大
• 两端梯度趋于平缓（可能引发梯度消失）

import matplotlib.pyplot as plt def plot_sigmoid(): z = torch.arange(-10, 10, 0.1) sigmoid = nn.Sigmoid() plt.figure(figsize=(10, 5)) plt.plot(z.numpy(), sigmoid(z).numpy(), label='Sigmoid') plt.axvline(0, color='r', linestyle='--', alpha=0.3) plt.axhline(0.5, color='r', linestyle='--', alpha=0.3) plt.xlabel("Input value (z)") plt.ylabel("Sigmoid output") plt.title("Sigmoid Function Curve") plt.grid(True) plt.legend() plt.show() plot_sigmoid()

2.2 两种模型构建方式对比

方案A：使用nn.Sequential快速搭建

sequential_model = nn.Sequential( nn.Linear(in_features=1, out_features=1), nn.Sigmoid() )

优势：

• 代码简洁，适合简单模型
• 层间自动传递数据
• 参数自动初始化

方案B：自定义nn.Module子类

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

优势：

• 灵活控制前向传播逻辑
• 可添加自定义方法
• 便于复杂模型扩展

实际选择建议：对于生产环境，推荐使用自定义类方式，虽然代码量稍多但更易维护和扩展。

3. 完整训练流程实现

3.1 数据准备与加载

构建一个模拟的二分类数据集：

def generate_data(n_samples=1000): torch.manual_seed(42) X = torch.randn(n_samples, 2) * 1.5 # 创建分类边界（线性可分） y = ((X[:, 0] + X[:, 1]) > 0).float() return X, y.unsqueeze(1) X, y = generate_data() print(f"特征形状: {X.shape}, 标签形状: {y.shape}") # 数据集可视化 plt.scatter(X[:,0], X[:,1], c=y.squeeze(), cmap='bwr', alpha=0.6) plt.xlabel("Feature 1") plt.ylabel("Feature 2") plt.title("Generated Classification Data") plt.colorbar() plt.show()

3.2 训练循环实现

def train_model(model, X, y, epochs=1000, lr=0.01): criterion = nn.BCELoss() # 二分类交叉熵损失 optimizer = torch.optim.SGD(model.parameters(), lr=lr) losses = [] for epoch in range(epochs): # 前向传播 outputs = model(X) loss = criterion(outputs, y) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() losses.append(loss.item()) if (epoch+1) % 100 == 0: print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}') return losses # 实例化模型 model = LogisticRegression(input_dim=2) loss_history = train_model(model, X, y) # 绘制损失曲线 plt.plot(loss_history) plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('Training Loss Curve') plt.grid(True) plt.show()

3.3 模型评估与决策边界

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 = torch.meshgrid(torch.linspace(x_min, x_max, 100), torch.linspace(y_min, y_max, 100)) # 预测网格点类别 with torch.no_grad(): Z = model(torch.cat([xx.reshape(-1,1), yy.reshape(-1,1)], dim=1)) Z = Z.reshape(xx.shape) > 0.5 # 绘制结果 plt.contourf(xx.numpy(), yy.numpy(), Z.numpy(), alpha=0.3, cmap='bwr') plt.scatter(X[:,0], X[:,1], c=y.squeeze(), cmap='bwr', edgecolors='k') plt.title("Decision Boundary") plt.xlabel("Feature 1") plt.ylabel("Feature 2") plt.show() plot_decision_boundary(model, X, y)

4. 实战技巧与问题排查

4.1 常见问题解决方案

4.2 性能优化技巧

1. 数据预处理标准化：

   from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_scaled = torch.FloatTensor(scaler.fit_transform(X))

2. 学习率调度：

   scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1) # 在训练循环中添加 scheduler.step()

3. 早停机制：

   best_loss = float('inf') patience = 10 counter = 0 for epoch in range(epochs): # ...训练代码... if loss.item() < best_loss: best_loss = loss.item() counter = 0 else: counter += 1 if counter >= patience: print("Early stopping triggered") break

4.3 模型保存与加载

# 保存整个模型 torch.save(model, 'logistic_regression.pth') # 仅保存参数（推荐） torch.save(model.state_dict(), 'lr_params.pth') # 加载模型 loaded_model = LogisticRegression(input_dim=2) loaded_model.load_state_dict(torch.load('lr_params.pth')) loaded_model.eval() # 设置为评估模式

5. 进阶扩展方向

5.1 多分类逻辑回归

通过修改输出层实现多分类：

class MulticlassLogisticRegression(nn.Module): def __init__(self, input_dim, num_classes): super().__init__() self.linear = nn.Linear(input_dim, num_classes) def forward(self, x): return torch.softmax(self.linear(x), dim=1)

5.2 正则化应用

L2正则化（权重衰减）：

optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.1)

5.3 GPU加速实现

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = LogisticRegression(input_dim=2).to(device) X, y = X.to(device), y.to(device)

在实际项目中，逻辑回归往往作为基线模型出现。虽然结构简单，但理解其PyTorch实现能帮助我们掌握深度学习模型的核心构建模式。当遇到更复杂模型时，这些基础技术会派上大用场。