DAY复习日

作业：

kaggle找到一个图像数据集，用cnn网络进行训练并且用grad-cam做可视化

进阶：并拆分成多个文件

数据集来源水母图像数据集 --- Jellyfish Image Dataset，对水母图片进行分类，共6个类别。

import os
import torch
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
 
# 设置随机种子确保结果可复现
torch.manual_seed(42)
np.random.seed(42)
 
# 设置中文字体支持
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题
 
# 定义数据预处理步骤，先将图像转换为张量，再进行归一化操作
train_transform = transforms.Compose([
    transforms.Resize((32, 32)),  # 调整图像大小为32x32
    # 随机水平翻转图像（概率0.5）
    transforms.RandomHorizontalFlip(),
    # 随机颜色抖动：亮度、对比度、饱和度和色调随机变化
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    # 随机旋转图像（最大角度15度）
    transforms.RandomRotation(15),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
 
test_transform = transforms.Compose([
    transforms.Resize((32, 32)),  # 调整图像大小为32x32
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
 
valid_transform = transforms.Compose([
    transforms.Resize((32, 32)),  # 调整图像大小为32x32
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
 
# 加载训练集和测试集、验证集
trainset = torchvision.datasets.ImageFolder(
    root='archive\Train_Test_Valid\Train', 
    transform=train_transform
)
# 修正路径问题，使用原始字符串或者双反斜杠避免转义问题
# 使用原始字符串解决路径转义问题
testset = torchvision.datasets.ImageFolder(
    root='archive\Train_Test_Valid\\test', 
    transform=test_transform
)
validset = torchvision.datasets.ImageFolder(
    root='archive\Train_Test_Valid\\valid',
    transform=valid_transform
)
 
# 定义类别名称
classes = trainset.classes
print(f"类别名称: {classes}")
 
 # 创建数据加载器，设置批量大小为32，打乱数据顺序（shuffle=True），使用2个线程加载数据
batch_size=64
# 训练集
trainloader = torch.utils.data.DataLoader(
    trainset, 
    batch_size=batch_size,
    shuffle=True, 
    num_workers=2
)
# 测试集
testloader = torch.utils.data.DataLoader(
    trainset, 
    batch_size=batch_size,
    shuffle=False,
    num_workers=2
)
# 验证集
validloader = torch.utils.data.DataLoader(
    validset,
    batch_size=batch_size,
    shuffle=False, 
    num_workers=2
)
 
 
# 定义一个简单的CNN模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 第一个卷积层，输入通道为3（彩色图像），输出通道为32，卷积核大小为3x3，填充为1以保持图像尺寸不变
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        # 第二个卷积层，输入通道为32，输出通道为64，卷积核大小为3x3，填充为1
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 第三个卷积层，输入通道为64，输出通道为128，卷积核大小为3x3，填充为1
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        # 最大池化层，池化核大小为2x2，步长为2，用于下采样，减少数据量并提取主要特征
        self.pool = nn.MaxPool2d(2, 2)
        # 第一个全连接层，输入特征数为128 * 4 * 4（经过前面卷积和池化后的特征维度），输出为512
        self.fc1 = nn.Linear(128 * 4 * 4, 512)
        # 第二个全连接层，输入为512，输出为len(classes)
        self.fc2 = nn.Linear(512, len(classes))
        
    def forward(self, x):
        # 第一个卷积层后接ReLU激活函数和最大池化操作，经过池化后图像尺寸变为原来的一半，这里输出尺寸变为16x16
        x = self.pool(F.relu(self.conv1(x)))  
        # 第二个卷积层后接ReLU激活函数和最大池化操作，输出尺寸变为8x8
        x = self.pool(F.relu(self.conv2(x)))  
        # 第三个卷积层后接ReLU激活函数和最大池化操作，输出尺寸变为4x4
        x = self.pool(F.relu(self.conv3(x)))  
        # 将特征图展平为一维向量，以便输入到全连接层
        x = x.view(-1, 128 * 4 * 4)
        # 第一个全连接层后接ReLU激活函数
        x = F.relu(self.fc1(x))
        # 第二个全连接层输出分类结果
        x = self.fc2(x)
        return x
 
# 初始化模型
model = SimpleCNN()
print("模型已创建")
 
# 如果有GPU则使用GPU，将模型转移到对应的设备上
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
model = model.to(device)
 
# 定义损失函数为交叉熵损失，用于分类任务
criterion = nn.CrossEntropyLoss()
# 定义优化器为Adam，用于更新模型参数，学习率设置为0.001
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
 
# 引入学习率调度器，在训练过程中动态调整学习率
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,        # 指定要控制的优化器（这里是Adam）
    mode='min',       # 监测的指标是"最小化"（如损失函数）
    patience=3,       # 如果连续3个epoch指标没有改善，才降低LR
    factor=0.5        # 降低LR的比例（新LR = 旧LR × 0.5）
)
 
# 训练模型（
def train_model(model, train_loader,test_loader,criterion, optimizer, scheduler,device,epochs=1):
    model.train()  
    # 记录每个 iteration 的损失
    all_iter_losses = []  # 存储所有 batch 的损失
    iter_indices = []     # 存储 iteration 序号
 
    # 记录每个 epoch 的准确率和损失
    train_acc_history = []
    test_acc_history = []
    train_loss_history = []
    test_loss_history = []
 
    for epoch in range(epochs):
        running_loss = 0.0
        correct=0
        total=0
 
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)  # 移至GPU
            
            optimizer.zero_grad()  # 梯度清零
            output = model(data)  # 前向传播
            loss = criterion(output, target)  # 计算损失
            loss.backward()  # 反向传播
            optimizer.step()  # 更新参数
            
            # 记录当前 iteration 的损失
            iter_loss = loss.item()
            all_iter_losses.append(iter_loss)
            iter_indices.append(epoch * len(train_loader) + batch_idx + 1)
            
            # 统计准确率和损失
            running_loss += iter_loss
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
            
            # 每100个批次打印一次训练信息
            if (batch_idx + 1) % 100 == 0:
                print(f'Epoch: {epoch+1}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} '
                      f'| 单Batch损失: {iter_loss:.4f} | 累计平均损失: {running_loss/(batch_idx+1):.4f}')
        
        # 计算当前epoch的平均训练损失和准确率
        epoch_train_loss = running_loss / len(train_loader)
        epoch_train_acc = 100. * correct / total
        train_acc_history.append(epoch_train_acc)
        train_loss_history.append(epoch_train_loss)
        
        # 测试阶段
        model.eval()  # 设置为评估模式
        test_loss = 0
        correct_test = 0
        total_test = 0
        
        with torch.no_grad():
            for data, target in test_loader:
                data, target = data.to(device), target.to(device)
                output = model(data)
                # print(output.shape)
                test_loss += criterion(output, target).item()
                _, predicted = output.max(1)
                total_test += target.size(0)
                correct_test += predicted.eq(target).sum().item()
        
        epoch_test_loss = test_loss / len(test_loader)
        epoch_test_acc = 100. * correct_test / total_test
        test_acc_history.append(epoch_test_acc)
        test_loss_history.append(epoch_test_loss)
 
        # 更新学习率调度器
        scheduler.step(epoch_test_loss)
 
        print(f'Epoch {epoch+1}/{epochs} 完成 | 训练准确率: {epoch_train_acc:.2f}% | 验证准确率: {epoch_test_acc:.2f}%')
    
    # 绘制所有 iteration 的损失曲线
    plot_iter_losses(all_iter_losses, iter_indices)
    print("训练完成")
    return epoch_test_acc  # 返回最终测试准确率
    
def plot_iter_losses(losses, indices):
    plt.figure(figsize=(10, 4))
    plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')
    plt.xlabel('Iteration（Batch序号）')
    plt.ylabel('损失值')
    plt.title('每个 Iteration 的训练损失')
    plt.legend()
    plt.grid(True)
    plt.tight_layout()
    plt.show()
 
 
# 7. 执行训练和测试
epochs = 50  # 增加训练轮次以获得更好效果
print("开始训练模型...")
final_accuracy = train_model(model, trainloader, testloader, criterion, optimizer, scheduler, device, epochs)
print(f"训练完成！最终验证准确率: {final_accuracy:.2f}%")
 
# 保存模型
torch.save(model.state_dict(), 'jellyfish_model.pth')
print("模型已保存为: jellyfish_model.pth")    

 

# 或者尝试加载预训练模型（如果存在）
try:
    # 尝试加载名为'cifar10_cnn.pth'的模型参数
    model.load_state_dict(torch.load('jellyfish_model.pth'))
    print("已加载预训练模型")
except:
    print("无法加载预训练模型，使用未训练模型或训练新模型")
    # 如果没有预训练模型，可以在这里调用train_model函数
    train_model(model, epochs=1)
    # 保存训练后的模型参数
    torch.save(model.state_dict(), 'jellyfish_model.pth')
 
# 设置模型为评估模式，此时模型中的一些操作（如dropout、batchnorm等）会切换到评估状态
model.eval()
                
 
# Grad-CAM实现
class GradCAM:
    def __init__(self, model, target_layer):
        self.model = model
        self.target_layer = target_layer
        self.gradients = None
        self.activations = None
        
        # 注册钩子，用于获取目标层的前向传播输出和反向传播梯度
        self.register_hooks()
        
    def register_hooks(self):
        # 前向钩子函数，在目标层前向传播后被调用，保存目标层的输出（激活值）
        def forward_hook(module, input, output):
            self.activations = output.detach()
        
        # 反向钩子函数，在目标层反向传播后被调用，保存目标层的梯度
        def backward_hook(module, grad_input, grad_output):
            self.gradients = grad_output[0].detach()
        
        # 在目标层注册前向钩子和反向钩子
        self.target_layer.register_forward_hook(forward_hook)
        self.target_layer.register_backward_hook(backward_hook)
    
    def generate_cam(self, input_image, target_class=None):
        # 前向传播，得到模型输出
        model_output = self.model(input_image)
        
        if target_class is None:
            # 如果未指定目标类别，则取模型预测概率最大的类别作为目标类别
            target_class = torch.argmax(model_output, dim=1).item()
        
        # 清除模型梯度，避免之前的梯度影响
        self.model.zero_grad()
        
        # 反向传播，构造one-hot向量，使得目标类别对应的梯度为1，其余为0，然后进行反向传播计算梯度
        one_hot = torch.zeros_like(model_output)
        one_hot[0, target_class] = 1
        model_output.backward(gradient=one_hot)
        
        # 获取之前保存的目标层的梯度和激活值
        gradients = self.gradients
        activations = self.activations
        
        # 对梯度进行全局平均池化，得到每个通道的权重，用于衡量每个通道的重要性
        weights = torch.mean(gradients, dim=(2, 3), keepdim=True)
        
        # 加权激活映射，将权重与激活值相乘并求和，得到类激活映射的初步结果
        cam = torch.sum(weights * activations, dim=1, keepdim=True)
        
        # ReLU激活，只保留对目标类别有正贡献的区域，去除负贡献的影响
        cam = F.relu(cam)
        
        # 调整大小并归一化，将类激活映射调整为与输入图像相同的尺寸（32x32），并归一化到[0, 1]范围
        cam = F.interpolate(cam, size=(32, 32), mode='bilinear', align_corners=False)
        cam = cam - cam.min()
        cam = cam / cam.max() if cam.max() > 0 else cam
        
        return cam.cpu().squeeze().numpy(), target_class

 

import warnings
warnings.filterwarnings("ignore")
import matplotlib.pyplot as plt
 
# 设置替代中文字体（适用于Linux）
plt.rcParams["font.family"] = ["WenQuanYi Micro Hei"]
plt.rcParams['axes.unicode_minus'] = False
# 选择一个随机图像
# idx = np.random.randint(len(validset))
idx = 6  # 选择测试集中的第101张图片 (索引从0开始)
image, label = validset[idx]
print(f"选择的图像类别: {classes[label]}")
 
# 转换图像以便可视化
def tensor_to_np(tensor):
    img = tensor.cpu().numpy().transpose(1, 2, 0)
    mean = np.array([0.5, 0.5, 0.5])
    std = np.array([0.5, 0.5, 0.5])
    img = std * img + mean
    img = np.clip(img, 0, 1)
    return img
 
# 添加批次维度并移动到设备
input_tensor = image.unsqueeze(0).to(device)
 
# 初始化Grad-CAM（选择最后一个卷积层）
grad_cam = GradCAM(model, model.conv3)
 
# # 生成热力图
heatmap, pred_class = grad_cam.generate_cam(input_tensor)
 
# 可视化
plt.figure(figsize=(12, 4))
 
# 原始图像
plt.subplot(1, 3, 1)
plt.imshow(tensor_to_np(image))
plt.title(f"原始图像: {classes[label]}")
plt.axis('off')
 
# 热力图
plt.subplot(1, 3, 2)
plt.imshow(heatmap, cmap='jet')
plt.title(f"Grad-CAM热力图: {classes[pred_class]}")
plt.axis('off')
 
# 叠加的图像
plt.subplot(1, 3, 3)
img = tensor_to_np(image)
heatmap_resized = np.uint8(255 * heatmap)
heatmap_colored = plt.cm.jet(heatmap_resized)[:, :, :3]
superimposed_img = heatmap_colored * 0.4 + img * 0.6
plt.imshow(superimposed_img)
plt.title("叠加热力图")
plt.axis('off')
 
plt.tight_layout()
# plt.savefig('grad_cam_result.png')
plt.show()
 
# # print("Grad-CAM可视化完成。已保存为grad_cam_result.png")

数据集来源水母图像数据集 --- Jellyfish Image Dataset，对水母图片进行分类，共6个类别。

@浙大疏锦行