day55

作业：一次稍微有点学术感觉的作业：

1. 对inception网络在cifar10上观察精度

2. 消融实验：引入残差机制和cbam模块分别进行消融

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import torchvision.models as models
import time
import copy
 
# 设置随机种子确保可复现性
torch.manual_seed(42)
 
# 数据预处理
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
 
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
 
# 加载CIFAR-10数据集
trainset = datasets.CIFAR10(root='./data', train=True,
                             download=True, transform=transform_train)
trainloader = DataLoader(trainset, batch_size=128,
                          shuffle=True, num_workers=2)
 
testset = datasets.CIFAR10(root='./data', train=False,
                            download=True, transform=transform_test)
testloader = DataLoader(testset, batch_size=100,
                         shuffle=False, num_workers=2)
 
# 定义CBAM模块
class ChannelAttention(nn.Module):
    def __init__(self, in_channels, reduction_ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)
        
        self.fc = nn.Sequential(
            nn.Conv2d(in_channels, in_channels // reduction_ratio, 1, bias=False),
            nn.ReLU(),
            nn.Conv2d(in_channels // reduction_ratio, in_channels, 1, bias=False)
        )
        
    def forward(self, x):
        avg_out = self.fc(self.avg_pool(x))
        max_out = self.fc(self.max_pool(x))
        out = avg_out + max_out
        return torch.sigmoid(out)
 
class SpatialAttention(nn.Module):
    def __init__(self, kernel_size=7):
        super(SpatialAttention, self).__init__()
        self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False)
        
    def forward(self, x):
        avg_out = torch.mean(x, dim=1, keepdim=True)
        max_out, _ = torch.max(x, dim=1, keepdim=True)
        out = torch.cat([avg_out, max_out], dim=1)
        out = self.conv(out)
        return torch.sigmoid(out)
 
class CBAM(nn.Module):
    def __init__(self, in_channels, reduction_ratio=16, kernel_size=7):
        super(CBAM, self).__init__()
        self.channel_att = ChannelAttention(in_channels, reduction_ratio)
        self.spatial_att = SpatialAttention(kernel_size)
        
    def forward(self, x):
        x = x * self.channel_att(x)
        x = x * self.spatial_att(x)
        return x
 
# 定义Inception模块
class InceptionModule(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
        super(InceptionModule, self).__init__()
        
        # 1x1卷积分支
        self.branch1 = nn.Sequential(
            nn.Conv2d(in_channels, ch1x1, kernel_size=1),
            nn.BatchNorm2d(ch1x1),
            nn.ReLU(True),
        )
        
        # 1x1卷积 -> 3x3卷积分支
        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
            nn.BatchNorm2d(ch3x3red),
            nn.ReLU(True),
            nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(ch3x3),
            nn.ReLU(True),
        )
        
        # 1x1卷积 -> 5x5卷积分支
        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
            nn.BatchNorm2d(ch5x5red),
            nn.ReLU(True),
            nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2),
            nn.BatchNorm2d(ch5x5),
            nn.ReLU(True),
        )
        
        # 3x3池化 -> 1x1卷积分支
        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, pool_proj, kernel_size=1),
            nn.BatchNorm2d(pool_proj),
            nn.ReLU(True),
        )
        
    def forward(self, x):
        branch1 = self.branch1(x)
        branch2 = self.branch2(x)
        branch3 = self.branch3(x)
        branch4 = self.branch4(x)
        
        outputs = [branch1, branch2, branch3, branch4]
        return torch.cat(outputs, 1)
 
# 基础Inception网络
class BasicInception(nn.Module):
    def __init__(self, num_classes=10):
        super(BasicInception, self).__init__()
        
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU(True)
        
        self.inception1 = InceptionModule(64, 32, 48, 64, 8, 16, 16)
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.inception2 = InceptionModule(128, 64, 64, 96, 16, 48, 32)
        self.pool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.inception3 = InceptionModule(240, 96, 48, 104, 8, 24, 32)
        
        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(256, num_classes)
        
    def forward(self, x):
        x = self.relu1(self.bn1(self.conv1(x)))
        
        x = self.inception1(x)
        x = self.pool1(x)
        
        x = self.inception2(x)
        x = self.pool2(x)
        
        x = self.inception3(x)
        
        x = self.global_pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        
        return x
 
# 带残差连接的Inception网络
class ResidualInception(nn.Module):
    def __init__(self, num_classes=10):
        super(ResidualInception, self).__init__()
        
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU(True)
        
        self.inception1 = InceptionModule(64, 32, 48, 64, 8, 16, 16)
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.inception2 = InceptionModule(128, 64, 64, 96, 16, 48, 32)
        self.pool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.inception3 = InceptionModule(240, 96, 48, 104, 8, 24, 32)
        
        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(256, num_classes)
        
        # 残差连接的1x1卷积
        self.res_conv1 = nn.Conv2d(64, 128, kernel_size=1, stride=2)
        self.res_conv2 = nn.Conv2d(128, 240, kernel_size=1, stride=2)
        
    def forward(self, x):
        identity = x
        
        x = self.relu1(self.bn1(self.conv1(x)))
        
        x = self.inception1(x)
        identity = self.res_conv1(identity)
        x += identity
        x = F.relu(x)
        x = self.pool1(x)
        
        identity = x
        
        x = self.inception2(x)
        identity = self.res_conv2(identity)
        x += identity
        x = F.relu(x)
        x = self.pool2(x)
        
        x = self.inception3(x)
        
        x = self.global_pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        
        return x
 
# 带CBAM模块的Inception网络
class CBAMInception(nn.Module):
    def __init__(self, num_classes=10):
        super(CBAMInception, self).__init__()
        
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU(True)
        
        self.inception1 = InceptionModule(64, 32, 48, 64, 8, 16, 16)
        self.cbam1 = CBAM(128)
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.inception2 = InceptionModule(128, 64, 64, 96, 16, 48, 32)
        self.cbam2 = CBAM(240)
        self.pool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.inception3 = InceptionModule(240, 96, 48, 104, 8, 24, 32)
        self.cbam3 = CBAM(256)
        
        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(256, num_classes)
        
    def forward(self, x):
        x = self.relu1(self.bn1(self.conv1(x)))
        
        x = self.inception1(x)
        x = self.cbam1(x)
        x = self.pool1(x)
        
        x = self.inception2(x)
        x = self.cbam2(x)
        x = self.pool2(x)
        
        x = self.inception3(x)
        x = self.cbam3(x)
        
        x = self.global_pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        
        return x
 
# 训练函数
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
    since = time.time()
    
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0
    
    for epoch in range(num_epochs):
        print(f'Epoch {epoch}/{num_epochs - 1}')
        print('-' * 10)
        
        # 每个epoch都有一个训练和验证阶段
        model.train()  # 训练模式
        
        running_loss = 0.0
        running_corrects = 0
        
        # 迭代训练数据
        for inputs, labels in trainloader:
            inputs = inputs.to(device)
            labels = labels.to(device)
            
            # 零梯度
            optimizer.zero_grad()
            
            # 前向传播
            # 只有在训练时才跟踪历史
            with torch.set_grad_enabled(True):
                outputs = model(inputs)
                _, preds = torch.max(outputs, 1)
                loss = criterion(outputs, labels)
                
                # 后向传播 + 优化
                loss.backward()
                optimizer.step()
            
            # 统计
            running_loss += loss.item() * inputs.size(0)
            running_corrects += torch.sum(preds == labels.data)
        
        scheduler.step()
        
        epoch_loss = running_loss / len(trainset)
        epoch_acc = running_corrects.double() / len(trainset)
        
        print(f'Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
        
        # 深拷贝模型
        if epoch_acc > best_acc:
            best_acc = epoch_acc
            best_model_wts = copy.deepcopy(model.state_dict())
        
        print()
    
    time_elapsed = time.time() - since
    print(f'Training complete in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s')
    print(f'Best train Acc: {best_acc:4f}')
    
    # 加载最佳模型权重
    model.load_state_dict(best_model_wts)
    return model
 
# 测试函数
def evaluate_model(model):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in testloader:
            inputs = inputs.to(device)
            labels = labels.to(device)
            
            outputs = model(inputs)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    accuracy = 100 * correct / total
    print(f'Accuracy of the network on the 10000 test images: {accuracy:.2f}%')
    return accuracy
 
# 设置设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")
 
# 实验结果记录
results = {}
 
# 实验1：基础Inception网络
print("===== 实验1: 基础Inception网络 =====")
model_basic = BasicInception().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model_basic.parameters(), lr=0.001, momentum=0.9)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
 
model_basic = train_model(model_basic, criterion, optimizer, scheduler, num_epochs=10)
basic_accuracy = evaluate_model(model_basic)
results["Basic Inception"] = basic_accuracy
 
# 实验2：带残差连接的Inception网络
print("\n===== 实验2: 带残差连接的Inception网络 =====")
model_residual = ResidualInception().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model_residual.parameters(), lr=0.001, momentum=0.9)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
 
model_residual = train_model(model_residual, criterion, optimizer, scheduler, num_epochs=10)
residual_accuracy = evaluate_model(model_residual)
results["Residual Inception"] = residual_accuracy
 
# 实验3：带CBAM模块的Inception网络
print("\n===== 实验3: 带CBAM模块的Inception网络 =====")
model_cbam = CBAMInception().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model_cbam.parameters(), lr=0.001, momentum=0.9)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
 
model_cbam = train_model(model_cbam, criterion, optimizer, scheduler, num_epochs=10)
cbam_accuracy = evaluate_model(model_cbam)
results["CBAM Inception"] = cbam_accuracy
 
# 输出实验结果对比
print("\n===== 实验结果对比 =====")
print("{:<20} {:<10}".format("模型", "准确率 (%)"))
print("-" * 30)
for model, acc in results.items():
    print("{:<20} {:<10.2f}".format(model, acc))