• 🍨 本文为🔗365天深度学习训练营中的学习记录博客
• 🍖 原作者：K同学啊

学习目的：初步了解深度学习的整体运行逻辑

一、 前期准备

关于环境

• 语言环境：Python3.13
• 编译器：vsCode
• 深度学习环境：torch==2.11.0+cu130；torchvision==0.26.0+cu130

1.设置GPU

设置分析环境：如有GPU则使用GPU

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

#设置GPU
device = toech.device("cuda" if torch.cuda.is_available() else "cpu")
device

代码运行结果：

2.数据导入

使用dataloader加载数据，并设置好基本的batch_size，同时对数据集进行训练集和测试集划分

torchvision.datasets是Pytorch自带的一个数据库，我们可以通过代码在线下载数据，这里使用的是torchvision.datasets中的MNIST数据集。

函数原型：

torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)

参数说明：

• root (string) ：数据地址
• train (string) ：True-训练集，False-测试集
• download (bool,optional) : 如果为True，从互联网上下载数据集，并把数据集放在root目录下。
• transform (callable, optional )：这里的参数选择一个你想要的数据转化函数，直接完成数据转化
• target_transform (callable,optional) ：接受目标并对其进行转换的函数/转换。

因为使用在线加载数据失败，因此下载后本地加载，故相对学习代码进行微调

train_ds = torchvision.datasets.MNIST('C:/Users/hsq/Desktop/train/data/data',
                                      train=True,
                                      transform=torchvision.transform.TOTENsor(),
                                      download=False)

test_ds = torchvision.datasets.MNIST('C:/Users/hsq/Desktop/train/data/data',
                                      train=False,
                                      transform=torchvision.transform.TOTENsor(),
                                      download=False)

代码理解

在下载好数据集后，我们需要对数据集进行加载并且将其划分为测试集和训练集（本身这个数据集就已经分好了训练集和测试集，所以只需分别读取即可）。

• transform=torchvision.transforms.ToTensor()：将原始图片（PIL Image 或 NumPy 数组）转换成 PyTorch 的张量（Tensor），并且把像素值从 0~255 缩放到 0~1。此外还会改变形状：原本是 (高, 宽) 变成 (通道数, 高, 宽)，对于灰度图通道数为 1。

因为代码从本地读取，所以download=False

torch.utils.data.DataLoader是Pytorch自带的一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。

函数原型：

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device='')

参数说明：

• dataset (string) ：加载的数据集
• batch_size (int,optional) ：每批加载的样本大小（默认值：1）
• shuffle (bool,optional) : 如果为True，每个epoch重新排列数据。
• sampler (Sampler or iterable, optional) ： 定义从数据集中抽取样本的策略。 可以是任何实现了 __len__ 的 Iterable。 如果指定，则不得指定 shuffle 。
• batch_sampler (Sampler or iterable, optional) ： 类似于sampler，但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。
• num_workers (int,optional) ： 用于数据加载的子进程数。 0 表示数据将在主进程中加载（默认值：0）。

batch_size = 32

train_d1 = torch.utils.data.DataLoader(train_ds,
                                       batch_size=batch_size,
                                       shuffle=True)

test_d1 = torch.utils.data.DataLoader(train_ds,
                                       batch_size=batch_size)

#查看图片数据格式
imgs, labels = next(iter(train_d1))
imgs.shape

代码理解

当数据集很大时，不能一次全部送入模型训练（内存/显存不够）。DataLoader 会把数据分成多个“小批次”（batch），每次迭代取一个 batch 进行训练。

• batch_size = 32：每批取 32 张图片。

• shuffle=True：在每个 epoch（完整遍历一次数据集）开始时打乱训练集顺序，防止模型记住顺序，提高泛化能力。

• iter(train_dl) 将 DataLoader 变成一个迭代器。

• next(...) 取出(train_dl)中的第一个 batch。

• imgs 的形状是 (32, 1, 28, 28) 表示：

  • 32：batch size

  • 1：通道数（灰度图）

  • 28×28：图片高宽

• labels 是对应的真实数字标签，形状为 (32,)。

代码运行结果

3. 数据可视化

import numpy as np

#指定图片大小
plt.figure(figsize=(20, 5))
for i, imgs in enumerate(imgs[:20]):
    #降维
    npimg = np.squeeze(imgs.numpy())
    #将整个图片分成2行10列，绘制第i+1个子图
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')

代码理解

• plt.figure(figsize=(20,5))：创建一个宽 20 英寸、高 5 英寸的画布。

• enumerate(imgs[:20])：取前 20 张图片，并同时得到索引 i 和图片张量。

• np.squeeze(imgs.numpy())：将 PyTorch 张量转成 NumPy 数组，并去掉维度为 1 的维（原本形状 (1,28,28) 变成 (28,28)）。

• plt.subplot(2,10,i+1)：把画布分成 2 行 10 列，在第 i+1 个小区域上画图。

• plt.imshow(npimg, cmap=plt.cm.binary)：显示灰度图，cmap=binary 用黑白二色显示。

• plt.axis('off')：不显示坐标轴。

代码运行结果

二、构建简单的CNN网络

import torch.n.functional as F

num_classes = 10

class Model(nn.Module):
     def __init__(self):
         super().__init__()
         #提取特征网络
         self.copy1 = nn.conv2d(1, 32, kernel_size=3)
         self.pool1 = nn.Maxpool2d(2)
         self.copy2 = nn.conv2d(32, 64, kernel_size=3)
         self.pool2 = nn.Maxpool2d(2)

         #分类网络
         self.fc1 = nn.Linear(1600, 64)
         self.fc2 = nn.Linear(64, num_classes)
       #向前传播
       def forward(self, x)
          x = self.pool1(F.relu(self.conv1(x)))
          x = self.pool2(F.relu(self.conv2(x)))

          x = torch.flatten(x, start_dim=1)

          x = F.relu(self.fc1(x))
          x = self.fc2(x)

          return x

代码理解

• 卷积层 Conv2d：提取图像的特征。

  • nn.Conv2d(1, 32, kernel_size=3)：输入通道 1（灰度图），输出通道 32（即提取 32 种特征），卷积核大小 3×3。

  • 第二层 nn.Conv2d(32, 64, kernel_size=3)：输入 32 个特征图，输出 64 个特征图。

• 激活函数 ReLU：F.relu 把负数变成 0，增加非线性，让网络能学习更复杂的模式。

• 池化层 MaxPool2d(2)：取 2×2 区域内的最大值，将图片尺寸缩小一半，减少计算量并提取主要特征。

• 全连接层 Linear：最后将特征图“拉平”成一维向量，传入普通神经网络层进行分类。

  • self.fc1 = nn.Linear(1600, 64)：输入 1600 个节点，输出 64 个节点。

  • self.fc2 = nn.Linear(64, 10)：输出 10 个节点，对应 0~9 的分数。

• torch.flatten(x, start_dim=1)：保持 batch 维度（dim=0），将其余维度拉平。经过两次卷积和池化：第一次卷积后：28→26（因为卷积核 3，无 padding），然后池化：26→13。第二次卷积：13→11，池化：11→5。最后特征图是 64×5×5 = 1600。

加载并打印模型

from rorchinfo import summary
#转移模型至GPU
model = Model().to(device)

summary(model)

代码运行结果

三、训练模型

1.超参数设置

loss_fn    = nn.CrossEntropyLoss #损失函数
learn_rate = 1e-2 #学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)

2. 编写训练函数

#训练循环
def tran(dtaloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    train_loss, train_acc = 0, 0 # 初始化训练损失和正确率

    for X, y in dataloader
        X, y = X.to(device), y.to(device)

        #计算预测误差
        pred = model(X)
        loss = loss_fn(pred, y)

        #反向传播
        optimizer.zero_grad()
        losss.backward()
        optimizer.step()

        #记录acc和loss
        train_acc += (pred.argmax(1) == y).type(torch,float).sum().item()
        train_loss += loss.item()
    
     train_acc  /= size
     train_loss /= num_batches

     return train_acc train_loss

代码理解

• size = len(dataloader.dataset)：数据集中总样本数（60000）。

• num_batches = len(dataloader)：批次数（60000/32≈1875）。

• 遍历每个 batch：

  • X, y = X.to(device), y.to(device)：把数据和标签搬到 GPU。

  • pred = model(X)：模型前向传播，输出形状 (batch, 10)。

  • loss = loss_fn(pred, y)：计算损失值。

  • optimizer.zero_grad()：清除之前的梯度（否则梯度会累加）。

  • loss.backward()：反向传播，计算每个参数的梯度。

  • optimizer.step()：根据梯度更新参数。

  • train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()

    • pred.argmax(1)：取每行最大值的位置（即预测的数字）。

    • == y：比较预测和真实标签，得到一个布尔张量。

    • .type(torch.float).sum().item()：转成浮点数（True→1, False→0）并求和，得到这个 batch 中正确预测的个数。

  • train_loss += loss.item()：累加损失值（item() 取出 Python 数值）。

• 循环结束后，train_acc /= size：总正确数 ÷ 总样本数 = 准确率。

• train_loss /= num_batches：平均损失。

3. 编写测试函数

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)
            
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

4. 正式训练

epochs     = 5
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_d1, model, loss_fn, opt)

    model,eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.apend(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f},  Test_acc:{:.1f}%，Test_loss:{:.3f}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')

代码理解

• epochs=5：对整个数据集训练 5 轮。

• model.train()：将模型设为“训练模式”。

• model.eval()：设为“评估模式”。

• 每个 epoch 结束后，把准确率和损失保存到列表中，用于后面画图。

• 打印每个 epoch 的训练/测试准确率和损失。

代码运行结果

四、 结果可视化

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

from datetime import datetime
current_time = datetime.now() # 获取当前时间

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

代码运行结果

五、基础概念学习

损失函数（Loss Function）

定义：衡量模型预测结果与真实答案之间差距的“评分器”。它的值越小，说明模型的预测越准确；值越大，说明模型越离谱

作用：模型刚开始训练时什么都不会，它会随机猜测。损失函数告诉我们“猜得有多差”。然后优化器（比如 SGD）会根据这个“差的程度”去调整模型的内部参数（权重），让下一次猜测更接近正确答案。这个过程反复进行，模型就逐渐学会了。

数学简化理解

交叉熵损失 = -log(模型预测正确的概率)

• 如果模型对正确类别的预测概率是 0.99，则损失 ≈ -log(0.99) ≈ 0.01（很小 → 好）

• 如果模型对正确类别的预测概率是 0.2，则损失 ≈ -log(0.2) ≈ 1.61（较大 → 差）

所以模型训练的目标就是最小化这个损失，让正确类别的预测概率尽量接近 1。

反向传播（Backpropagation）

具体过程：

1. 先做一次正向传播，得到损失值。（即损失函数）

2. 然后从输出层开始，利用链式法则，一层层往回计算每一个参数对损失的“影响力”（即导数/梯度）。

3. 最后，优化器（如 SGD）根据这些梯度来更新参数：参数 = 参数 - 学习率 × 梯度，让损失下降。

六、感悟

这其实是一个多分类的学习任务，相当于利用CNN神经网络进行图片特征提取、识别，最终对图片进行10分类（0-9）。整体流程大致理解，但是对于内部相关基础概念仍需掌握学习.