半监督与全监督在代码上的区别

半监督训练和全监督训练在代码实现上有一些显著的不同，主要在于数据处理、损失函数设计和训练流程的不同。以下是半监督训练和全监督训练在代码实现中的一些关键区别：

数据处理

全监督训练通常使用完全标注的数据集进行训练，每个样本都有对应的标签。

半监督训练则使用部分标注的数据集和大量未标注的数据集，需要设计额外的机制来利用未标注数据。

代码实现区别

1. 数据加载和预处理：

   • 全监督训练中，数据加载器只需加载带有标签的数据。
   • 半监督训练中，需要同时加载带有标签和不带标签的数据，并进行不同的预处理。

2. 损失函数设计：

   • 全监督训练中，损失函数通常只考虑带有标签的数据。
   • 半监督训练中，损失函数需要同时考虑带有标签的数据的监督损失和不带标签的数据的一些一致性或伪标签损失。

3. 训练流程：

   • 全监督训练中，训练流程只需处理带有标签的数据。
   • 半监督训练中，训练流程需要同时处理带有标签和不带标签的数据，并计算不同的损失。

示例代码

下面是一个简化的示例，展示了全监督训练和半监督训练在代码实现上的主要区别：

全监督训练
 

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

# 假设我们有一个简单的模型
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(10, 1)

    def forward(self, x):
        return self.linear(x)

# 全监督训练的数据集和数据加载器
supervised_dataset = SupervisedDataset()  # 仅有标注的数据集
supervised_loader = DataLoader(supervised_dataset, batch_size=32, shuffle=True)

model = SimpleModel().cuda()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 全监督训练流程
for epoch in range(num_epochs):
    model.train()
    for data, target in supervised_loader:
        data, target = data.cuda(), target.cuda()
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

半监督训练
 

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

# 假设我们有一个简单的模型
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(10, 1)

    def forward(self, x):
        return self.linear(x)

# 半监督训练的数据集和数据加载器
supervised_dataset = SupervisedDataset()  # 有标注的数据集
unsupervised_dataset = UnsupervisedDataset()  # 无标注的数据集

supervised_loader = DataLoader(supervised_dataset, batch_size=32, shuffle=True)
unsupervised_loader = DataLoader(unsupervised_dataset, batch_size=32, shuffle=True)

model = SimpleModel().cuda()
criterion_supervised = nn.MSELoss()  # 用于有标签数据的损失函数
criterion_unsupervised = nn.MSELoss()  # 用于无标签数据的损失函数（例如伪标签损失）
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 半监督训练流程
for epoch in range(num_epochs):
    model.train()
    unsupervised_iter = iter(unsupervised_loader)
    for data, target in supervised_loader:
        data, target = data.cuda(), target.cuda()
        
        # 获取无标签数据
        try:
            unsupervised_data = next(unsupervised_iter)
        except StopIteration:
            unsupervised_iter = iter(unsupervised_loader)
            unsupervised_data = next(unsupervised_iter)
        unsupervised_data = unsupervised_data.cuda()
        
        optimizer.zero_grad()
        
        # 有标签数据的损失
        output = model(data)
        loss_supervised = criterion_supervised(output, target)
        
        # 无标签数据的损失（例如使用伪标签）
        unsupervised_output = model(unsupervised_data)
        pseudo_labels = generate_pseudo_labels(unsupervised_output)  # 生成伪标签
        loss_unsupervised = criterion_unsupervised(unsupervised_output, pseudo_labels)
        
        # 总损失
        loss = loss_supervised + lambda_unsupervised * loss_unsupervised
        loss.backward()
        optimizer.step()