以下是针对图像数据不足时的处理方法对比及对应的PyTorch代码示例：

---

方法对比表

方法	适用场景	优点	缺点	实现复杂度
数据增强	小规模标注数据	简单快速，直接提升泛化能力	多样性有限，依赖领域知识	低
迁移学习	领域相关的预训练模型可用	利用预训练特征，减少训练时间	需领域相关性，模型可能过拟合	中
生成对抗网络 (GAN)	需要生成逼真图像	生成多样化数据，突破标注限制	训练不稳定，计算资源消耗大	高
半监督学习	有少量标注+大量未标注数据	利用未标注数据，提升模型鲁棒性	依赖半监督算法设计	中
自监督学习	无标注数据可用	无需人工标注，学习通用特征	预训练任务需与下游任务相关	中

---

PyTorch代码示例

1. 数据增强（Data Augmentation）

import torch
from torchvision import transforms, datasets
from torch.utils.data import DataLoader

# 定义数据增强策略
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),  # 水平翻转
    transforms.RandomRotation(15),      # 随机旋转
    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 颜色扰动
    transforms.ToTensor(),
])

# 加载CIFAR-10数据集（示例）
dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 查看增强后的图像
images, labels = next(iter(dataloader))
print("Augmented images shape:", images.shape)  # (batch, 3, 32, 32)

代码解释：

• 使用transforms.Compose组合多种增强方法（翻转、旋转、颜色扰动）。
• 加载CIFAR-10数据集并应用增强，生成多样化的训练数据。

---

2. 迁移学习（Transfer Learning）

import torch
import torch.nn as nn
from torchvision import models, datasets, transforms

# 加载预训练ResNet18并替换最后一层
model = models.resnet18(pretrained=True)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)  # 假设目标任务是10分类

# 冻结除最后一层外的所有参数
for param in model.parameters():
    param.requires_grad = False
model.fc.requires_grad = True

# 加载数据（示例：CIFAR-10）
train_transform = transforms.Compose([
    transforms.Resize(224),  # ResNet输入尺寸为224x224
    transforms.ToTensor(),
])
dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 训练（仅微调最后一层）
optimizer = torch.optim.Adam(model.fc.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

代码解释：

• 使用预训练ResNet18，冻结所有层参数，仅训练新添加的全连接层。
• 调整输入尺寸以适应预训练模型，适用于小规模数据集分类任务。

---

3. 生成对抗网络（GAN）

import torch
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 生成器定义
class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 784),  # 生成28x28图像（如MNIST）
            nn.Tanh()
        )
    
    def forward(self, z):
        return self.model(z).view(-1, 1, 28, 28)

# 训练GAN（简化示例）
generator = Generator()
discriminator = nn.Sequential(
    nn.Flatten(),
    nn.Linear(784, 256),
    nn.LeakyReLU(0.2),
    nn.Linear(256, 1),
    nn.Sigmoid()
)

# 加载MNIST数据集
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

代码解释：

• 生成器从随机噪声生成图像，判别器区分真实与生成图像。
• 通过对抗训练生成新数据（需进一步实现训练循环）。

---

4. 半监督学习（Semi-Supervised Learning）

import torch
import torch.nn as nn
from torchvision import transforms, datasets
from torch.utils.data import DataLoader

# 假设有部分标注数据和大量未标注数据
labeled_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
unlabeled_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor()
]))

# 模型定义
model = nn.Sequential(
    nn.Conv2d(3, 16, 3), nn.ReLU(), nn.MaxPool2d(2),
    nn.Flatten(), nn.Linear(16*15*15, 10)
)

# 伪标签训练（简化示例）
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(10):
    for labeled_images, labels in DataLoader(labeled_dataset, batch_size=32):
        # 监督损失
        outputs = model(labeled_images)
        loss_supervised = nn.CrossEntropyLoss()(outputs, labels)
        
        # 无监督损失（伪标签）
        unlabeled_images, _ = next(iter(DataLoader(unlabeled_dataset, batch_size=32)))
        pseudo_labels = torch.argmax(model(unlabeled_images), dim=1)
        loss_unsupervised = nn.CrossEntropyLoss()(model(unlabeled_images), pseudo_labels)
        
        total_loss = loss_supervised + 0.1 * loss_unsupervised
        optimizer.zero_grad()
        total_loss.backward()
        optimizer.step()

代码解释：

• 结合少量标注数据和大量未标注数据，通过伪标签（模型预测结果）增强训练信号。
• 平衡监督损失和无监督损失，提升模型泛化能力。

---

5. 自监督学习（Self-Supervised Learning）

import torch
import torch.nn as nn
from torchvision import transforms, datasets

# 自监督任务：预测图像旋转角度
class RotationPrediction(nn.Module):
    def __init__(self):
        super().__init__()
        self.backbone = nn.Sequential(
            nn.Conv2d(3, 16, 3), nn.ReLU(), nn.MaxPool2d(2),
            nn.Flatten()
        )
        self.rotation_head = nn.Linear(16*15*15, 4)  # 预测4种旋转角度（0°, 90°, 180°, 270°）
    
    def forward(self, x):
        features = self.backbone(x)
        return self.rotation_head(features)

# 数据增强（旋转）
transform = transforms.Compose([
    transforms.RandomRotation([0, 90, 180, 270]),
    transforms.ToTensor(),
])
dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 训练自监督任务
model = RotationPrediction()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for images, _ in dataloader:  # 忽略原始标签
    angles = torch.randint(0, 4, (images.shape[0],))  # 随机生成旋转角度标签
    rotated_images = torch.rot90(images, k=1, dims=[2, 3])  # 实际需根据angles旋转
    outputs = model(rotated_images)
    loss = nn.CrossEntropyLoss()(outputs, angles)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

代码解释：

• 通过预测图像旋转角度的预训练任务，学习通用特征表示。
• 预训练后可将backbone迁移至下游任务（如分类）。

---

总结

• 数据增强和迁移学习是资源有限时的首选。
• GAN适合需要生成多样化数据的场景，但需高性能计算资源。
• 半监督和自监督适合有大量未标注数据的场景，可显著提升模型鲁棒性。