当前位置： 首页 > news >正文

day43/60

news 来源：原创 2025/6/27 14:46:47

@浙大疏锦行

DAY 43 复习日

作业：

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

进阶：并拆分成多个文件

豆包：

一、项目实战拆解：用 CNN+Grad-CAM 分析 Kaggle 图像数据

1. 项目背景与目标

Kaggle 是数据科学竞赛平台，提供大量图像数据集（如猫狗分类、花卉识别等）。我们要用 CNN 训练模型，再用 Grad-CAM 可视化模型 “关注” 的图像区域，解释模型决策逻辑。

2. 核心技术与文件拆分

将项目拆分为多个文件，模拟真实工程结构：

 

plaintext

project/
├── data/                  # 存放数据集（Kaggle下载后放这里）
├── src/                   # 源代码
│   ├── data_loader.py     # 数据加载与预处理（Day32知识点：灰度/彩色图像格式）
│   ├── model.py           # CNN模型定义（Day39知识点：模型参数、显存占用）
│   ├── train.py           # 模型训练（Day42知识点：回调函数保存模型）
│   ├── grad_cam.py        # Grad-CAM实现（Day42知识点：Hook函数获取特征图/梯度）
│   └── visualize.py       # 可视化结果（Day39知识点：绘图与底层库调用）
└── notebooks/             # Jupyter实验笔记├── data_explore.ipynb # 数据探索└── grad_cam_demo.ipynb # 可视化演示
3. 核心代码逻辑（伪代码）

data_loader.py（Day32 知识应用）：

 

python

运行

from torchvision import transformsdef get_transforms():return transforms.Compose([transforms.Resize(224),transforms.RandomHorizontalFlip(),  # 数据增强（Day39知识点）transforms.ToTensor(),transforms.Normalize(mean, std),])def load_data(data_path):dataset = ImageFolder(data_path, transform=get_transforms())dataloader = DataLoader(dataset, batch_size=32)  # Day39知识点：batchsize与显存return dataloader
 

model.py（Day39 知识应用）：

 

python

运行

import torch.nn as nnclass CNN(nn.Module):def __init__(self):super().__init__()self.conv1 = nn.Conv2d(3, 16, 3)  # 卷积层（Day39知识点：卷积操作）self.bn1 = nn.BatchNorm2d(16)     # Batch归一化（Day39知识点）self.pool = nn.MaxPool2d(2, 2)self.fc = nn.Linear(16*111*111, 10)  # 全连接层def forward(self, x):x = self.pool(torch.relu(self.bn1(self.conv1(x))))  # 卷积→BN→激活→池化x = x.view(x.size(0), -1)  # 展平（Day39知识点）return self.fc(x)
 

grad_cam.py（Day42 知识应用）：

 

python

运行

import torchclass GradCAM:def __init__(self, model, target_layer):self.model = modelself.target_layer = target_layerself.feature_maps = Noneself.gradient = None# 注册模块钩子（Day42知识点）target_layer.register_forward_hook(self.save_feature_maps)target_layer.register_backward_hook(self.save_gradient)def save_feature_maps(self, module, input, output):self.feature_maps = output  # 保存前向传播的特征图def save_gradient(self, module, grad_input, grad_output):self.gradient = grad_output[0]  # 保存反向传播的梯度def __call__(self, x, class_idx=None):# 前向传播output = self.model(x)if class_idx is None:class_idx = torch.argmax(output, dim=1)# 反向传播self.model.zero_grad()one_hot = torch.zeros_like(output)one_hot[0, class_idx] = 1output.backward(gradient=one_hot, retain_graph=True)# 计算Grad-CAM（Day42知识点）weights = torch.mean(self.gradient, dim=(2, 3), keepdim=True)cam = torch.sum(weights * self.feature_maps, dim=1).squeeze()return cam

二、关键知识点复盘（结合项目）

1. 图像数据与显存（Day39）
  • 数据格式：彩色（RGB 三通道）/ 灰度（单通道），通过transforms处理（data_loader.py）。
  • 显存占用：
    • 模型参数：CNN 的卷积层、全连接层参数存于显存（model.py）。
    • Batch 归一化：nn.BatchNorm2d在显存中调整批次数据分布。
    • 数据批量：batch_size=32影响单次训练的显存占用（train.py）。
2. 卷积神经网络（Day39）
  • 网络结构：
    • 卷积层：提取图像特征（如边缘、纹理）。
    • 池化层：降维，减少参数（如MaxPool2d）。
    • 全连接层：分类决策。
  • 常见流程：输入→卷积→BN→池化→激活→展平→全连接（model.py）。
3. Hook 函数与 Grad-CAM（Day42）
  • 模块钩子：在目标卷积层注册，获取前向传播的特征图和反向传播的梯度（grad_cam.py）。
  • Grad-CAM 流程：
    1. 用钩子获取特征图和梯度；
    2. 梯度加权特征图，生成热力图；
    3. 叠加原图，可视化模型关注区域（visualize.py）。
4. 代码工程化（本次项目进阶）
  • 模块化设计：
    • 数据处理、模型定义、训练、可视化分离，避免代码冗余。
    • 通过import复用功能，提升可维护性（如train.py导入model.py的 CNN）。

三、项目执行步骤（动手实操）

  1. 数据准备：从 Kaggle 下载数据集，放入data/目录。
  2. 环境配置：安装 PyTorch、torchvision、matplotlib。
  3. 模型训练：运行python train.py，保存最佳模型。
  4. Grad-CAM 可视化：运行python visualize.py --image_path path/to/image.jpg，生成热力图。
 

通过这个项目，你将 Day32、Day39、Day42 的知识点串联起来，从数据处理到模型训练，再到解释模型决策，形成完整的深度学习闭环！ 🚀

数据集：10 Big Cats of the Wild - Image Classification

import torch
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
import os# 设置随机种子确保结果可复现
torch.manual_seed(42)
np.random.seed(42)# 将 'path/to/your_dataset' 替换为你的数据集所在的根目录
data_dir = './data/10 Big Cats of the Wild - Image Classification'
train_dir = os.path.join(data_dir, 'train')
test_dir = os.path.join(data_dir, 'test')if not os.path.isdir(data_dir):raise FileNotFoundError(f"Dataset directory not found at '{data_dir}'. "f"Please update the 'data_dir' variable to your dataset's path.")transform = transforms.Compose([transforms.Resize((32, 32)),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])# 加载训练集和测试集
trainset = torchvision.datasets.ImageFolder(root=train_dir, transform=transform)
testset = torchvision.datasets.ImageFolder(root=test_dir, transform=transform)# 从训练数据集中自动获取类别名称和数量
classes = trainset.classes
num_classes = len(classes)
print(f"从数据集中找到 {num_classes} 个类别: {classes}")# 创建数据加载器
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2)# --- MODIFICATION 3: 动态调整CNN模型以适应你的数据集 ---
class SimpleCNN(nn.Module):def __init__(self, num_classes): # 将类别数量作为参数传入super(SimpleCNN, self).__init__()self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)self.pool = nn.MaxPool2d(2, 2)# 输入特征数128 * 4 * 4取决于输入图像大小和网络结构。# 由于我们将所有图像调整为32x32，经过3次2x2的池化后，尺寸变为 32 -> 16 -> 8 -> 4。所以这里是4*4。self.fc1 = nn.Linear(128 * 4 * 4, 512)# **重要**: 输出层的大小现在由num_classes决定self.fc2 = nn.Linear(512, num_classes)def forward(self, x):x = self.pool(F.relu(self.conv1(x)))  x = self.pool(F.relu(self.conv2(x)))  x = self.pool(F.relu(self.conv3(x)))  x = x.view(-1, 128 * 4 * 4)x = F.relu(self.fc1(x))x = self.fc2(x)return x# 初始化模型，传入你的数据集的类别数量
model = SimpleCNN(num_classes=num_classes)
print("模型已创建")# 如果有GPU则使用GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)# 训练模型函数 (现在使用传入的trainloader)
def train_model(model, trainloader, epochs=5): # 增加训练周期以获得更好效果criterion = nn.CrossEntropyLoss()optimizer = torch.optim.Adam(model.parameters(), lr=0.001)print("开始训练...")for epoch in range(epochs):running_loss = 0.0for i, data in enumerate(trainloader, 0):inputs, labels = datainputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()if i % 100 == 99:print(f'[{epoch + 1}, {i + 1:5d}] 损失: {running_loss / 100:.3f}')running_loss = 0.0print("训练完成")# 定义模型保存路径
model_save_path = 'my_custom_cnn.pth'# 尝试加载预训练模型
try:model.load_state_dict(torch.load(model_save_path))print(f"已从 '{model_save_path}' 加载预训练模型")
except FileNotFoundError:print("无法加载预训练模型，将开始训练新模型。")train_model(model, trainloader, epochs=5) # 训练新模型torch.save(model.state_dict(), model_save_path) # 保存训练好的模型print(f"新模型已训练并保存至 '{model_save_path}'")# 设置模型为评估模式
model.eval()# Grad-CAM实现 (这部分无需修改)
class GradCAM:def __init__(self, model, target_layer):self.model = modelself.target_layer = target_layerself.gradients = Noneself.activations = Noneself.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 = torch.zeros_like(model_output)one_hot[0, target_class] = 1model_output.backward(gradient=one_hot, retain_graph=True) # retain_graph=True可能需要gradients = self.gradientsactivations = self.activationsweights = torch.mean(gradients, dim=(2, 3), keepdim=True)cam = torch.sum(weights * activations, dim=1, keepdim=True)cam = F.relu(cam)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 camreturn cam.cpu().squeeze().numpy(), target_classgrad_cam = GradCAM(model, model.conv3)# 从测试集中获取一张图片
img, label = testset[0]
img_tensor = img.unsqueeze(0).to(device)# 生成CAM
cam, predicted_class_idx = grad_cam.generate_cam(img_tensor)# 可视化结果
def visualize_cam(img, cam, predicted_class, true_class):img = img.permute(1, 2, 0).numpy() # 转换回 (H, W, C)# 反归一化以便显示img = img * 0.5 + 0.5img = np.clip(img, 0, 1)heatmap = plt.cm.jet(cam)heatmap = heatmap[:, :, :3] # 去掉alpha通道overlay = heatmap * 0.4 + img * 0.6plt.figure(figsize=(10, 5))plt.subplot(1, 3, 1)plt.imshow(img)plt.title(f'Original Image\nTrue: {true_class}')plt.axis('off')plt.subplot(1, 3, 2)plt.imshow(heatmap)plt.title('Grad-CAM Heatmap')plt.axis('off')plt.subplot(1, 3, 3)plt.imshow(overlay)plt.title(f'Overlay\nPredicted: {predicted_class}')plt.axis('off')plt.show()# 显示结果
predicted_class_name = classes[predicted_class_idx]
true_class_name = classes[label]
visualize_cam(img, cam, predicted_class_name, true_class_name)

相关文章：

  • 桌面小屏幕实战课程: DesktopScreen 12 WiFi AP
  • RPC（Remote Procedure Call）技术解析
  • 面试破局：告别流水账，用“故事思维”重塑自我介绍
  • 视频关键帧提取
  • recipes的版本比较老如何更新到新版本？
  • 【计网】期末复习知识总结
  • 基于STM32的智能书房系统的设计
  • 49-有效的字母异位词
  • chili3d笔记23 正交投影3d重建笔记4 点到线2
  • QT实现一个三轴位移台的控制界面
  • WinAppDriver 自动化测试：C#篇
  • Nginx配置文件介绍和基本使用
  • Instagram和facebook广告对比解析
  • unibest+uniapp+vue3+TS+Wot UI分包
  • [特殊字符]推客带货小程序解决方案——0门槛裂变营销，佣金赚不停！
  • 板凳-------Mysql cookbook学习 （十--11）
  • MIT 6.S081—环境配置和初步学习day01（VMware和Ubuntu安装）
  • c++17标准std::filesystem常用函数
  • uni-app的UTS插件开发，调用鸿蒙原生API
  • 网络安全 vs 信息安全的本质解析：数据盾牌与网络防线的辩证关系关系