数据增强：经典方法与 AutoAugment

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

# 对比：有增强 vs 无增强的训练循环
class SimpleTrainer:
    def __init__(self, model: nn.Module, use_augmentation: bool = True):
        self.model = model
        self.use_augmentation = use_augmentation
        self.transform = T.Compose([
            T.RandomHorizontalFlip(p=0.5),
            T.RandomRotation(15),
            T.ColorJitter(brightness=0.2, contrast=0.2),
        ]) if use_augmentation else T.ToTensor()

    def train_step(self, images, labels):
        if self.use_augmentation:
            images = torch.stack([self.transform(img) for img in images])
        logits = self.model(images)
        loss = nn.CrossEntropyLoss()(logits, labels)
        return loss

import numpy as np
import matplotlib.pyplot as plt

# 可视化数据增强对训练/验证准确率的影响
def plot_overfitting_comparison():
    epochs = np.arange(1, 101)
    # 无增强：训练准确率飙升，验证准确率停滞
    no_aug_train = 1 - np.exp(-epochs / 10) + 0.02 * np.sin(epochs)
    no_aug_val = 1 - np.exp(-epochs / 30)

    # 有增强：训练稍慢但验证更好
    aug_train = 1 - np.exp(-epochs / 15)
    aug_val = 1 - np.exp(-epochs / 12)

    plt.figure(figsize=(10, 6))
    plt.plot(epochs, no_aug_train, 'r--', label='无增强-训练')
    plt.plot(epochs, no_aug_val, 'r-', label='无增强-验证')
    plt.plot(epochs, aug_train, 'b--', label='有增强-训练')
    plt.plot(epochs, aug_val, 'b-', label='有增强-验证')
    plt.legend()
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.title('数据增强对过拟合的影响')
    plt.savefig('augmentation_effect.png', dpi=150)

plot_overfitting_comparison()

import torchvision.transforms as T
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader

# 经典增强流水线
train_transform = T.Compose([
    T.RandomHorizontalFlip(p=0.5),         # 50%概率水平翻转
    T.RandomCrop(32, padding=4),           # 随机裁剪，边缘填充4像素
    T.RandomRotation(degrees=15),          # ±15度随机旋转
    T.ColorJitter(
        brightness=0.2,                     # 亮度抖动 ±20%
        contrast=0.2,                       # 对比度抖动 ±20%
        saturation=0.2,                     # 饱和度抖动 ±20%
        hue=0.1                             # 色调偏移 ±10%
    ),
    T.ToTensor(),
    T.Normalize((0.4914, 0.4822, 0.4465),  # CIFAR-10 均值
                (0.2470, 0.2435, 0.2616)),  # CIFAR-10 标准差
])

train_dataset = CIFAR10(root='./data', train=True, download=True, transform=train_transform)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)

import cv2
import numpy as np
import matplotlib.pyplot as plt

def demonstrate_basic_augmentation(image_path):
    """演示各种基础增强效果"""
    img = cv2.imread(image_path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

    # 水平翻转
    h_flip = cv2.flip(img, 1)
    # 旋转 30 度
    h, w = img.shape[:2]
    M = cv2.getRotationMatrix2D((w/2, h/2), 30, 1.0)
    rotated = cv2.warpAffine(img, M, (w, h))
    # 随机裁剪
    crop = img[20:200, 20:200]
    # 亮度调整
    bright = cv2.convertScaleAbs(img, alpha=1.3, beta=30)

    fig, axes = plt.subplots(2, 2, figsize=(10, 10))
    axes[0, 0].imshow(h_flip)
    axes[0, 0].set_title('水平翻转')
    axes[0, 1].imshow(rotated)
    axes[0, 1].set_title('旋转30度')
    axes[1, 0].imshow(crop)
    axes[1, 0].set_title('随机裁剪')
    axes[1, 1].imshow(bright)
    axes[1, 1].set_title('亮度提升')
    for ax in axes.flat:
        ax.axis('off')
    plt.tight_layout()
    plt.show()

import torch
import torch.nn.functional as F

def mixup_data(x, y, alpha=0.2, device='cuda'):
    """Mixup: 线性混合两张图像和标签"""
    if alpha > 0:
        lam = np.random.beta(alpha, alpha)
    else:
        lam = 1.0

    batch_size = x.size(0)
    index = torch.randperm(batch_size, device=device)

    # 混合图像
    mixed_x = lam * x + (1 - lam) * x[index, :]
    # 混合标签（返回四元组用于损失计算）
    y_a, y_b = y, y[index]
    return mixed_x, y_a, y_b, lam

def mixup_criterion(criterion, pred, y_a, y_b, lam):
    """Mixup 损失计算"""
    return lam * criterion(pred, y_a) + (1 - lam) * criterion(pred, y_b)

# 使用方式
images, labels = next(iter(train_loader))
mixed_images, labels_a, labels_b, lam = mixup_data(images, labels, alpha=0.2)
outputs = model(mixed_images)
loss = mixup_criterion(F.cross_entropy, outputs, labels_a, labels_b, lam)
loss.backward()

import torch
import numpy as np

def cutmix_data(x, y, alpha=1.0, device='cuda'):
    """CutMix: 随机区域替换"""
    if alpha > 0:
        lam = np.random.beta(alpha, alpha)
    else:
        lam = 1.0

    batch_size = x.size(0)
    index = torch.randperm(batch_size, device=device)

    # 生成随机裁剪区域
    r_x = torch.randint(0, x.size(3), (1,), device=device)
    r_y = torch.randint(0, x.size(2), (1,), device=device)
    # 根据 lam 计算裁剪区域大小
    r_w = int(x.size(3) * (1 - lam))
    r_h = int(x.size(2) * (1 - lam))

    # 确保边界不越界
    bbx1 = torch.clamp(r_x - r_w // 2, 0, x.size(3))
    bby1 = torch.clamp(r_y - r_h // 2, 0, x.size(2))
    bbx2 = torch.clamp(r_x + r_w // 2, 0, x.size(3))
    bby2 = torch.clamp(r_y + r_h // 2, 0, x.size(2))

    # 执行区域替换
    x[:, :, bby1:bby2, bbx1:bbx2] = x[index, :, bby1:bby2, bbx1:bbx2]

    # 计算面积比例作为新的 lambda
    lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (x.size(2) * x.size(3)))
    return x, y, y[index], lam

import torchvision.transforms as T
from torchvision.transforms import autoaugment, InterpolationMode

# RandAugment 实现（torchvision 内置）
transform = T.Compose([
    T.RandomResizedCrop(224, interpolation=InterpolationMode.BICUBIC),
    T.RandomHorizontalFlip(),
    # N=2: 随机选2种变换, M=9: 强度为9(范围0~10)
    autoaugment.RandAugment(num_ops=2, magnitude=9),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406],
                std=[0.229, 0.224, 0.225]),
])

# 手动实现 RandAugment 的核心逻辑
import random

RAND_AUGMENT_OPS = [
    'autocontrast', 'equalize', 'rotate', 'posterize',
    'solarize', 'color', 'contrast', 'brightness',
    'sharpness', 'shear_x', 'shear_y', 'translate_x',
    'translate_y', 'invert'
]

def apply_rand_augment(image, N=2, M=9, max_M=10):
    """简化版 RandAugment"""
    ops = random.sample(RAND_AUGMENT_OPS, N)
    for op in ops:
        magnitude = M / max_M  # 归一化到 [0, 1]
        image = apply_operation(image, op, magnitude)
    return image

import matplotlib.pyplot as plt
import numpy as np
from PIL import Image, ImageEnhance, ImageOps

# 可视化 RandAugment 的不同强度效果
def visualize_magnitude_effect(image_path):
    img = Image.open(image_path)
    magnitudes = [0, 3, 5, 7, 9]

    fig, axes = plt.subplots(1, 5, figsize=(15, 3))
    for i, m in enumerate(magnitudes):
        mag_factor = m / 10.0
        # 用 Color 变换演示强度效果
        enhanced = ImageEnhance.Color(img).enhance(1 + mag_factor)
        enhanced = ImageEnhance.Brightness(enhanced).enhance(1 + mag_factor * 0.5)
        axes[i].imshow(enhanced)
        axes[i].set_title(f'M={m}')
        axes[i].axis('off')
    plt.suptitle('RandAugment 不同强度对比')
    plt.tight_layout()
    plt.show()

# N 值实验：选择几种变换的组合数
def count_strategy_combinations(num_ops, pool_size=14):
    """计算不同 N 的策略组合数量"""
    from math import comb
    for n in range(1, num_ops + 1):
        # 每种变换有 10 个强度等级
        combinations = comb(pool_size, n) * (10 ** n)
        print(f'N={n}: 约 {combinations:,} 种策略组合')

count_strategy_combinations(4)

from torchvision.transforms import autoaugment, InterpolationMode
import torchvision.transforms as T

# 使用 torchvision 内置的 ImageNet AutoAugment 策略
transform = T.Compose([
    T.RandomResizedCrop(224, interpolation=InterpolationMode.BICUBIC),
    T.RandomHorizontalFlip(),
    autoaugment.AutoAugment(
        policy=autoaugment.AutoAugmentPolicy.IMAGENET,
        interpolation=InterpolationMode.BICUBIC
    ),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406],
                std=[0.229, 0.224, 0.225]),
])

# AutoAugmentPolicy 有三种预训练策略:
# IMAGENET  - 在 ImageNet 上搜索
# CIFAR10   - 在 CIFAR-10 上搜索
# SVHN      - 在 SVHN 手写数字上搜索

# 简化版 AutoAugment 搜索框架示意
import torch
import torch.nn as nn

class PolicyController(nn.Module):
    """控制器 RNN：生成数据增强策略"""
    def __init__(self, num_ops=16, num_magnitudes=11, n_sub_policies=5):
        super().__init__()
        self.lstm = nn.LSTMCell(128, 128)
        # 每个子策略: 2个操作 + 2个强度
        self.op_predictors = nn.ModuleList([
            nn.Linear(128, num_ops) for _ in range(2 * n_sub_policies)
        ])
        self.mag_predictors = nn.ModuleList([
            nn.Linear(128, num_magnitudes) for _ in range(2 * n_sub_policies)
        ])

    def sample_policy(self):
        """采样一个策略（简化版，实际用强化学习采样）"""
        policy = []
        h, c = torch.randn(1, 128), torch.randn(1, 128)
        for op_pred, mag_pred in zip(self.op_predictors, self.mag_predictors):
            h, c = self.lstm(h.unsqueeze(0), (h, c))
            op_logits = op_pred(h)
            mag_logits = mag_pred(h)
            op = torch.multinomial(torch.softmax(op_logits, -1), 1)
            mag = torch.multinomial(torch.softmax(mag_logits, -1), 1)
            policy.append((op.item(), mag.item()))
        return policy

import torch
import torch.nn as nn
import numpy as np

def measure_input_gradient_sensitivity(model, images, labels, n_samples=50):
    """测量模型对输入扰动的梯度敏感性（越小越鲁棒）"""
    model.eval()
    sensitivities = []

    for _ in range(n_samples):
        img = images[0].unsqueeze(0).clone().requires_grad_(True)
        output = model(img)
        loss = nn.CrossEntropyLoss()(output, labels[0:1])

        # 计算输入梯度
        grad = torch.autograd.grad(loss, img)[0]
        sensitivity = grad.norm().item()
        sensitivities.append(sensitivity)

    return np.mean(sensitivities), np.std(sensitivities)

# 对比：有增强训练的模型 vs 无增强训练的模型
model_aug = load_model('trained_with_aug.pth')
model_no_aug = load_model('trained_without_aug.pth')
mean_sens_aug, std_aug = measure_input_gradient_sensitivity(model_aug, test_images, test_labels)
mean_sens_no_aug, std_no_aug = measure_input_gradient_sensitivity(model_no_aug, test_images, test_labels)
print(f'有增强: {mean_sens_aug:.4f} ± {std_aug:.4f}')
print(f'无增强: {mean_sens_no_aug:.4f} ± {std_no_aug:.4f}')

import torch
import torch.nn as nn

# 对比三种正则化方法的组合效果
class RegularizedModel(nn.Module):
    def __init__(self, base_model, dropout_rate=0.5, weight_decay=1e-4):
        super().__init__()
        self.base_model = base_model
        self.dropout = nn.Dropout(dropout_rate)

    def forward(self, x):
        x = self.base_model(x)
        x = self.dropout(x)
        return x

# 训练配置：三种正则化同时使用
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
    weight_decay=1e-4,              # 权重衰减 (L2 正则化)
)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)

# 数据增强作为第三种正则化
train_transform = T.Compose([
    T.RandomHorizontalFlip(),
    T.RandAugment(num_ops=2, magnitude=9),  # 输入空间扰动
    T.ToTensor(),
    T.Normalize(mean, std),
])

import albumentations as A
from albumentations.pytorch import ToTensorV2
import cv2
import numpy as np

# Albumentations 高性能增强流水线
# 同时处理图像 + 分割掩码 + 检测框
transform = A.Compose([
    A.HorizontalFlip(p=0.5),
    A.ShiftScaleRotate(
        shift_limit=0.0625,
        scale_limit=0.1,
        rotate_limit=15,
        p=0.5
    ),
    A.OneOf([
        A.RandomBrightnessContrast(
            brightness_limit=0.2, contrast_limit=0.2, p=1),
        A.HueSaturationValue(
            hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=1),
    ], p=0.5),
    A.CoarseDropout(
        max_holes=8, max_height=16, max_width=16,
        min_holes=1, min_height=8, min_width=8,
        fill_value=0, p=0.5
    ),
    A.Normalize(mean=[0.485, 0.456, 0.406],
                std=[0.229, 0.224, 0.225]),
    ToTensorV2(),
], additional_targets={'mask': 'mask'})

# 使用示例
image = cv2.imread('sample.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
augmented = transform(image=image, mask=mask)
aug_image = augmented['image']      # (3, H, W) tensor
aug_mask = augmented['mask']        # (H, W) tensor

import torch
from torch.utils.data import Dataset, DataLoader
import albumentations as A
from albumentations.pytorch import ToTensorV2

# 自定义 Dataset 集成 Albumentations
class AugmentedDataset(Dataset):
    def __init__(self, image_paths, labels, transform=None):
        self.image_paths = image_paths
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        import cv2
        image = cv2.imread(self.image_paths[idx])
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        if self.transform:
            augmented = self.transform(image=image)
            image = augmented['image']

        return image, self.labels[idx]

# 构建 DataLoader（多进程并行增强）
train_dataset = AugmentedDataset(
    image_paths=train_paths,
    labels=train_labels,
    transform=transform,
)
train_loader = DataLoader(
    train_dataset,
    batch_size=64,
    shuffle=True,
    num_workers=4,        # 4个worker并行做数据增强
    pin_memory=True,      # 加速 CPU→GPU 传输
    prefetch_factor=2,    # 预取 2 个 batch
)