PyTorch 二分类实战：输出通道为1用Sigmoid，为2用Softmax的3个代码示例

PyTorch二分类任务中输出通道与激活函数的实战选择

在深度学习模型的构建过程中，二分类任务是最基础也最常见的场景之一。PyTorch作为当前主流的深度学习框架，为开发者提供了灵活的选择空间。本文将深入探讨二分类任务中输出通道维度（1或2）与激活函数（Sigmoid/Softmax）的对应关系，并通过三个典型场景的代码示例展示实际应用。

1. 二分类任务的基础原理

二分类任务的核心是将输入数据划分为两个互斥的类别。在神经网络中，这通常通过最后一层的输出和适当的激活函数来实现。选择输出通道维度和激活函数时，需要考虑以下关键因素：

• 输出通道为1：使用Sigmoid函数将输出压缩到(0,1)区间，表示样本属于正类的概率
• 输出通道为2：使用Softmax函数将两个输出归一化为概率分布，表示样本属于两个类别的概率

这两种方法在数学上是等价的，但实现细节和损失函数的选择有所不同。下面是一个简单的对比表格：

提示：PyTorch的BCEWithLogitsLoss已经内置了Sigmoid计算，可以提升数值稳定性，建议优先使用而非手动添加Sigmoid

2. 标准二分类任务实现（输出通道为1）

对于大多数常规的二分类问题，输出通道设为1并使用Sigmoid激活是最直接的选择。下面是一个完整的PyTorch实现示例：

import torch import torch.nn as nn import torch.nn.functional as F class BinaryClassifier(nn.Module): def __init__(self, input_dim): super().__init__() self.fc1 = nn.Linear(input_dim, 64) self.fc2 = nn.Linear(64, 32) self.output = nn.Linear(32, 1) # 输出层1个单元 def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) # 不显式添加Sigmoid，因为BCEWithLogitsLoss会自动处理 return self.output(x) # 示例用法 model = BinaryClassifier(input_dim=100) criterion = nn.BCEWithLogitsLoss() # 内置Sigmoid的二元交叉熵 optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 训练循环示例 for epoch in range(10): optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs.squeeze(), labels.float()) loss.backward() optimizer.step()

关键实现细节：

1. 输出层设置为1个神经元，不使用显式Sigmoid激活
2. 使用BCEWithLogitsLoss作为损失函数，它结合了Sigmoid和BCE计算
3. 注意输出需要squeeze()以匹配标签形状

3. 二分类语义分割实现（输出通道为2）

在语义分割任务中，即使只有两类（如前景/背景），通常也会使用输出通道为2的结构，因为这样可以利用CrossEntropyLoss的像素级分类能力：

class SegmentationModel(nn.Module): def __init__(self): super().__init__() # 示例编码器-解码器结构 self.encoder = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2) ) self.decoder = nn.Sequential( nn.Conv2d(64, 32, kernel_size=3, padding=1), nn.ReLU(), nn.Upsample(scale_factor=2) ) self.output = nn.Conv2d(32, 2, kernel_size=1) # 输出通道为2 def forward(self, x): x = self.encoder(x) x = self.decoder(x) return self.output(x) # 使用示例 model = SegmentationModel() criterion = nn.CrossEntropyLoss() # 自动应用Softmax optimizer = torch.optim.Adam(model.parameters()) # 训练时不需要额外处理输出 outputs = model(inputs) # shape: [B, 2, H, W] loss = criterion(outputs, labels) # labels: [B, H, W] with values 0 or 1

这种实现的特点包括：

• 输出空间维度（H,W）保持不变
• 每个像素位置都有两个通道的输出
• CrossEntropyLoss会自动应用Softmax并计算损失

4. 多标签分类的特殊情况

当处理多标签分类（一个样本可能属于多个类别）时，即使只有两个类别，也应该采用Sigmoid激活而非Softmax：

class MultiLabelClassifier(nn.Module): def __init__(self, input_dim): super().__init__() self.layer1 = nn.Linear(input_dim, 128) self.layer2 = nn.Linear(128, 64) self.output = nn.Linear(64, 2) # 两个独立的二分类 def forward(self, x): x = F.relu(self.layer1(x)) x = F.relu(self.layer2(x)) return self.output(x) # 不应用Softmax # 使用示例 model = MultiLabelClassifier(256) criterion = nn.BCEWithLogitsLoss() # 对每个输出单独计算Sigmoid+BCE optimizer = torch.optim.RMSprop(model.parameters()) # 训练时需要为每个类提供标签 outputs = model(inputs) # shape: [B, 2] labels = labels.float() # shape: [B, 2] with 0/1 values loss = criterion(outputs, labels)

多标签场景的关键特征：

• 每个类别的预测是独立的
• 输出值之间没有约束关系（可以同时为高概率）
• 使用BCEWithLogitsLoss而非CrossEntropyLoss

5. 损失函数的选择与优化技巧

根据不同的输出结构和激活函数选择，损失函数的使用也有所不同。以下是常见组合：

1. Sigmoid + BCEWithLogitsLoss：

   • 最常用的二分类组合
   • 数值稳定，避免log(0)问题
   • 示例：

     criterion = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([1.5])) # 处理类别不平衡

2. Softmax + CrossEntropyLoss：

   • PyTorch已优化实现，效率高
   • 适用于互斥分类
   • 示例：

     criterion = nn.CrossEntropyLoss(weight=torch.tensor([1.0, 2.0])) # 类别权重

3. 自定义组合：

   • 特殊场景可能需要自定义损失
   • 示例（Dice Loss用于分割）：

     def dice_loss(pred, target): smooth = 1. pred = pred.sigmoid() intersect = (pred * target).sum() return 1 - (2. * intersect + smooth) / (pred.sum() + target.sum() + smooth)

注意：对于输出通道为2使用Sigmoid的情况（不推荐），需要手动计算损失：

criterion = nn.BCELoss() outputs = model(inputs) probs = torch.sigmoid(outputs) loss = criterion(probs, labels)

在实际项目中，我发现BCEWithLogitsLoss对于大多数二分类任务已经足够，它的主要优势在于：

• 内置Sigmoid的数值稳定实现
• 支持类别权重和正样本权重
• 自动处理维度匹配问题

对于分割任务，结合CrossEntropyLoss和Dice Loss的混合损失通常能获得更好的效果：

def hybrid_loss(pred, target): ce = nn.CrossEntropyLoss()(pred, target) pred_softmax = torch.softmax(pred, dim=1) dice = dice_loss(pred_softmax[:, 1], target.float()) return ce + dice