第P1周：实现mnist手写数字识别

>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客**
>- **🍖 原作者：[K同学啊 | 接辅导、项目定制](https://mtyjkh.blog.csdn.net/)**

一、前言

二、我的环境

三、前期准备

1.设置GPU

2.导入数据

（1）第一步：使用dataset下载MNIST数据集，并划分好训练集与测试集

（2）第二步：使用dataloader加载数据，并设置好基本的batch_size

（3）取一个批次查看数据格式

3.数据可视化

四、构建简单的cnn网络

（1）第一步构建cnn网络模型

（2）第二步：加载并打印模型

（3）第三步：输出结果编辑

五、训练模型

1.设置超参数

2.编写训练函数

3.编写测试函数

4.正式训练

（1）第一步：训练

（2）获取结果：编辑

六、结果可视化

编辑

七、知识点详解

1. MNIST手写数字数据集介绍

2. 神经网络程序说明

八、总结

一、前言

(1)感谢K同学，课程是优质的至少很清晰明了，初学很舒服

（2）自己摆烂太久了，自驱力太差，要改正，自己要有计划

（3）希望自己能端正心态，好好的去学，坚持下去

二、我的环境

电脑系统：Windows 10
语言环境：Python 3.9.18
编译器：jupyter notebook
深度学习环境：
PyTorch 版本: 2.0.1+cpu
Torchvision 版本: 0.15.2+cpu
显卡及显存：AMD Radeon(TM) Graphics

三、前期准备

1.设置GPU

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision# 设置硬件设备，如果有GPU则使用，没有则使用cpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

输出结果

证明本机只有CPU

2.导入数据

（1）第一步：使用dataset下载MNIST数据集，并划分好训练集与测试集

train_ds = torchvision.datasets.MNIST('data', train=True, transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensordownload=True)test_ds  = torchvision.datasets.MNIST('data', train=False, transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensordownload=True)

⭐ torchvision.datasets.MNIST详解

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

参数说明：

root (string) ：数据地址，以上代码为data

train (string) ：True-训练集，False-测试集

download (bool,optional) : 如果为True，从互联网上下载数据集，并把数据集放在root目录下。

transform (callable, optional )：这里的参数选择一个你想要的数据转化函数，直接完成数据转化

target_transform (callable,optional) ：接受目标并对其进行转换的函数/转换。

（2）第二步：使用dataloader加载数据，并设置好基本的batch_size

batch_size = 32train_dl = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True)test_dl  = torch.utils.data.DataLoader(test_ds, batch_size=batch_size)

⭐ torch.utils.data.DataLoader详解

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

参数说明：

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）。
pin_memory (bool,optional) : 如果为 True，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。如果数据元素是自定义类型，或者collate_fn返回一个自定义类型的批次。
drop_last (bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。（默认值：False）
timeout (numeric,optional) : 设置数据读取的超时时间，超过这个时间还没读取到数据的话就会报错。（默认值：0）
worker_init_fn (callable,optional) ：如果不是 None，这将在步长之后和数据加载之前在每个工作子进程上调用，并使用工作 id（[0，num_workers - 1] 中的一个 int）的顺序逐个导入。（默认：None）

（3）取一个批次查看数据格式

# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))
imgs.shape

输出结果：批次32，通道1，宽28高28.

train_dl 是一个 PyTorch 数据加载器（DataLoader），用于加载训练数据集。通常情况下，数据加载器会将数据集分成小批量（batches）进行处理。
iter(train_dl) 将数据加载器转换为一个迭代器（iterator），使得我们可以使用 Python 的 next() 函数来逐个访问数据加载器中的元素。
next() 函数用于获取迭代器中的下一个元素。在这里，它被用来获取 train_dl 中的下一个批量数据。
imgs, labels = ... 这行代码是 Python 的解构赋值语法。它将从 next() 函数返回的元素中提取出两个变量：imgs 和 labels。
imgs 变量将包含一个批量的图像数据，而 labels 变量将包含相应的标签数据。这些图像和标签是从训练数据集中提取的。
imgs是一个张量（tensor），.shape是张量对象的一个属性，用来查看张量的形状。
形状的表示方式是[batch_size, channel, height, weight]

3.数据可视化

 #这段代码是使用Matplotlib库来绘制图像的#导入NumPy库并将其命名为np，用于处理数组和数值计算。
import numpy as np# 创建一个新的图形窗口，指定图片大小，图像大小为20宽、5高的绘图(单位为英寸inch)，这里使用了  
#Matplotlib库中的figure函数。
plt.figure(figsize=(20, 5)) #遍历一个包含图像数据的迭代器或列表的前20个元素，并使用enumerate函数同时获取索引i和对应的图像#imgs。
for i, imgs in enumerate(imgs[:20]):# 维度缩减
#npimg = np.squeeze(imgs.numpy())：将PyTorch张量转换为NumPy数组，并使用np.squeeze函数去除数
#组中维度为1的维度，以便后续绘图。npimg = np.squeeze(imgs.numpy())# 将整个figure分成2行10列，绘制第i+1个子图。plt.subplot(2, 10, i+1)plt.imshow(npimg, cmap=plt.cm.binary)plt.axis('off')#plt.subplot(2, 10, i+1)：创建一个2行10列的子图表格，并定位到第i+1个子图。这里使用了#Matplotlib库中的subplot函数。#plt.imshow(npimg, cmap=plt.cm.binary)：在当前子图中显示图像。npimg是处理后的NumPy数组，#cmap=plt.cm.binary表示使用二值化的颜色映射（黑白色调）来显示图像。#plt.axis('off')：关闭坐标轴显示，这样在图像周围不会显示坐标轴刻度。
#plt.show()  如果你使用的是Pycharm编译器，请加上这行代码
#通过以上步骤，代码实现了在Matplotlib中绘制一个大小为20宽、5高的图形窗口，并展示了前20个图像数据（假设imgs包含了20个图像数据），每行显示10个图像，以黑白色调显示，并关闭了坐标轴的显示。

squeeze()函数的功能是从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5, 1），使用过这个函数后，结果为（5, ）

为什么要去除维度为1的维度：在深度学习中，通常使用张量（tensor）来表示数据。张量是多维数组的一种扩展形式，可以是0维（标量）、1维（向量）、2维（矩阵）、3维（立方体）等。在处理图像数据时，通常使用3维张量来表示图像，其形状通常为[批次大小, 通道数, 高度, 宽度]。
在PyTorch或其他深度学习框架中，加载图像数据后会生成相应的张量对象。然而，有时候图像数据的维度可能会有一些冗余，比如在加载单通道灰度图像时，其维度可能会是[1, 高度, 宽度]，这里的1表示通道数。在这种情况下，我们可能希望去除这个维度为1的通道数维度，以便后续的处理和显示。
np.squeeze函数的作用就是去除数组中维度为1的维度。例如，对于形状为[1, 高度, 宽度]的张量，经过np.squeeze后，形状会变为[高度, 宽度]，去除了维度为1的通道数维度。这样做的好处包括：

1.简化数据表示：去除维度为1的冗余维度，使数据的表示更加简洁和清晰。
2.避免错误：有时候在进行数据处理或绘图时，对于维度为1的通道数维度可能会造成一些错误，去除这些维度可以避免这些问题的出现。
3.兼容性：一些图像处理或显示函数可能对维度要求较严格，去除冗余维度可以提高代码的兼容性。

因此，在绘图前将PyTorch张量转换为NumPy数组，并使用np.squeeze函数去除维度为1的冗余通道数维度，可以使数据更加符合绘图或处理的要求。

输出结果：

四、构建简单的cnn网络

（1）第一步构建cnn网络模型

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小

nn.MaxPool2d为池化层，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小
nn.ReLU为激活函数，使模型可以拟合非线性数据
nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）
nn.Sequential可以按构造顺序连接网络，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍

网络结构图（可放大查看）

import torch.nn.functional as Fnum_classes = 10  # 图片的类别数class Model(nn.Module):def __init__(self):super().__init__()# 特征提取网络self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 第一层卷积,卷积核大小为3*3self.pool1 = nn.MaxPool2d(2)                  # 设置池化层，池化核大小为2*2self.conv2 = nn.Conv2d(32, 64, kernel_size=3) # 第二层卷积,卷积核大小为3*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

这段代码定义了一个名为 Model 的神经网络模型，该模型包含了特征提取网络和分类网络两部分。
下面是对代码中各部分的中文逐行解释：
import torch.nn.functional as F导入 PyTorch 中的函数模块 torch.nn.functional，通常用于定义神经网络的各种激活函数和损失函数。
num_classes = 10  # 定义了变量 num_classes，表示图片的类别数，这个值在这里被设置为 10。class Model(nn.Module):定义了一个名为 Model 的类，该类继承自 nn.Module 类，表示这是一个 PyTorch 的模型。def __init__(self):super().__init__()在初始化函数中调用父类 nn.Module 的初始化函数。# 特征提取网络self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 第一层卷积,卷积核大小为3*3self.pool1 = nn.MaxPool2d(2)                  # 设置池化层，池化核大小为2*2self.conv2 = nn.Conv2d(32, 64, kernel_size=3) # 第二层卷积,卷积核大小为3*3   self.pool2 = nn.MaxPool2d(2) 定义了特征提取网络，包括两个卷积层和两个最大池化层。conv1 和 conv2 是卷积层，使用 nn.Conv2d 进行定义，分别将输入的通道数从 1 扩展到 32，再从 32 扩展到 64。pool1 和 pool2 分别是最大池化层，使用 nn.MaxPool2d 进行定义，池化核大小为 2*2。# 分类网络self.fc1 = nn.Linear(1600, 64)          self.fc2 = nn.Linear(64, num_classes)定义了分类网络，包括两个全连接层。fc1 和 fc2 是全连接层，使用 nn.Linear 进行定义，fc1 的输入维度为 1600，输出维度为 64；fc2 的输入维度为 64，输出维度为 num_classes，即图片的类别数。# 前向传播def forward(self, x):定义了前向传播函数，即模型从输入到输出的计算过程。x = self.pool1(F.relu(self.conv1(x)))     x = self.pool2(F.relu(self.conv2(x)))通过卷积层和池化层对输入 x 进行特征提取和降维操作，并使用 ReLU 激活函数进行非线性变换。x = torch.flatten(x, start_dim=1)将特征张量展平成一维张量，以便进行全连接层的操作。x = F.relu(self.fc1(x))x = self.fc2(x)通过两个全连接层进行分类操作，最终输出预测结果。return x返回最终的输出结果。

（2）第二步：加载并打印模型

from torchinfo import summary
# 将模型转移到GPU中（我们模型运行均在GPU中进行）
model = Model().to(device)summary(model)

（3）第三步：输出结果

结果解读：

五、训练模型

1.设置超参数

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

2.编写训练函数

# 训练循环
def train(dataloader, model, loss_fn, optimizer):size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片num_batches = len(dataloader)   # 批次数目，1875（60000/32）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)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失# 反向传播optimizer.zero_grad()  # grad属性归零loss.backward()        # 反向传播optimizer.step()       # 每一步自动更新# 记录acc与losstrain_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc  /= sizetrain_loss /= num_batchesreturn train_acc, train_loss这段代码是用于进行模型的训练。让我解释每个部分的作用：1.loss_fn = nn.CrossEntropyLoss(): 这行代码创建了一个损失函数 (loss_fn)，使用的是交叉熵损失函数 (CrossEntropyLoss)。损失函数用于度量模型输出与实际标签之间的差异，帮助我们优化模型的参数。
2.learn_rate = 1e-2: 这行代码定义了学习率 (learn_rate) 的值。学习率决定了在每次参数更新时的步长大小。较大的学习率可能导致参数更新过大，无法收敛；而较小的学习率可能导致收敛速度缓慢。学习率需要根据具体问题和实验结果进行调整。
3.opt = torch.optim.SGD(model.parameters(), lr=learn_rate): 这行代码创建了一个优化器对象 (opt)，使用的是随机梯度下降优化器 (SGD)。通过传入模型的参数 (model.parameters()) 和学习率 (learn_rate) 来初始化优化器。优化器的作用是根据损失函数计算的梯度来更新模型的参数，以使损失函数的值最小化。
4.train(dataloader, model, loss_fn, optimizer): 这是一个名为 train 的函数，用于执行训练循环。它接受数据加载器 (dataloader)、模型 (model)、损失函数 (loss_fn) 和优化器 (optimizer) 作为参数。
5.size = len(dataloader.dataset): 这行代码获取训练集的大小，即数据加载器中包含的总样本数。这在后面计算准确率时会用到。
6.num_batches = len(dataloader): 这行代码获取批次的数量，即数据加载器中的迭代次数。这也用于后面计算损失的平均值。
7.train_loss, train_acc = 0, 0: 这行代码初始化训练损失 (train_loss) 和训练准确率 (train_acc) 的值。
8.for X, y in dataloader: 这是一个循环，遍历数据加载器中的每个批次。每次迭代获取一个批次的输入数据 (X) 和对应的标签 (y)。
9.X, y = X.to(device), y.to(device): 这行代码将输入数据和标签移动到指定的设备 (例如 GPU) 上进行加速计算。
10.pred = model(X): 这行代码通过模型 (model) 对输入数据进行前向传播，得到预测输出 (pred)。
11.loss = loss_fn(pred, y): 这行代码使用损失函数 (loss_fn) 计算预测输出 (pred) 和实际标签 (y) 之间的损失值。这个损失值用于度量模型的预测与实际标签之间的差异。
12.optimizer.zero_grad(): 这行代码将优化器 (optimizer) 中的梯度值归零，避免梯度在反向传播过程中累积。
13.loss.backward(): 这行代码执行反向传播，计算损失函数对模型参数的梯度。
14.optimizer.step(): 这行代码根据计算的梯度更新模型的参数，优化模型。
15.train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item(): 这行代码计算训练过程中的准确率。它统计预测输出 (pred) 的最大值对应的类别与实际标签 (y) 相等的数量，并累加到训练准确率 (train_acc) 中。
16.train_loss += loss.item(): 这行代码将每个批次的损失值累加到训练损失 (train_loss) 中。
17.train_acc  /= size: 这行代码计算平均训练准确率，除以训练集的大小 (size)。
18.train_loss /= num_batches: 这行代码计算平均训练损失，除以批次的数量 (num_batches)。
19.return train_acc, train_loss: 这行代码返回训练的准确率和损失值。总的来说，这段代码用于迭代训练模型。它计算模型预测与实际标签之间的损失，并根据损失值进行参数更新，同时记录训练过程中的准确率和损失值。通过多次迭代训练，模型可以逐渐优化并提高在训练数据上的性能。

1. optimizer.zero_grad()

函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。

2. loss.backward()

PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。

具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用tensor.backward()，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。

更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用loss.backward()后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。

如果没有进行tensor.backward()的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。

3. optimizer.step()

step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。

pred.argmax(1) 返回数组 pred 在第一个轴（即行）上最大值所在的索引。这通常用于多类分类问题中，其中 pred 是一个包含预测概率的二维数组，每行表示一个样本的预测概率分布。

(pred.argmax(1) == y)是一个布尔值，其中等号是否成立代表对应样本的预测是否正确（True 表示正确，False 表示错误）。

.type(torch.float)是将布尔数组的数据类型转换为浮点数类型，即将 True 转换为 1.0，将 False 转换为 0.0。

.sum()是对数组中的元素求和，计算出预测正确的样本数量。

.item()将求和结果转换为标量值，以便在 Python 中使用或打印。

(pred.argmax(1) == y).type(torch.float).sum().item()表示计算预测正确的样本数量，并将其作为一个标量值返回。这通常用于评估分类模型的准确率或计算分类问题的正确预测数量。

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)# 计算losstarget_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  /= sizetest_loss /= num_batchesreturn test_acc, test_loss

4.正式训练

（1）第一步：训练

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_dl, model, loss_fn, opt)model.eval()epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)train_acc.append(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')
这段代码是一个简单的训练循环，用于训练和评估一个神经网络模型。让我逐行解释：1.epochs = 5: 定义了训练的总轮数，即训练将在数据集上进行5轮。
2.train_loss = [], train_acc = [], test_loss = [], test_acc = []: 初始化了四个空列表，用于存储每个epoch的训练和测试损失以及准确率。
3.for epoch in range(epochs):: 开始了一个循环，该循环会在整个训练数据集上进行指定数量的轮次。
4.model.train(): 将模型设置为训练模式，这会启用模型中的训练特定的行为，例如启用Dropout或Batch Normalization。
5.epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt): 调用train函数进行一个epoch的训练，并返回该epoch的训练准确率和损失。
6.model.eval(): 将模型设置为评估模式，这会关闭训练模式下的一些特殊行为，例如Dropout。
7.epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn): 调用test函数评估模型在测试集上的性能，并返回测试准确率和损失。
8.train_acc.append(epoch_train_acc), train_loss.append(epoch_train_loss), test_acc.append(epoch_test_acc), test_loss.append(epoch_test_loss): 将每个epoch的训练和测试准确率以及损失值添加到相应的列表中。
9.template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}'): 定义了一个格式化字符串模板，用于打印每个epoch的训练和测试结果。
10.print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss)): 使用上述模板打印每个epoch的训练和测试结果。
11.print('Done'): 打印完成训练的消息。整个循环的目的是在每个epoch结束后，记录并打印模型在训练集和测试集上的准确率和损失值，并将这些值存储起来以供后续分析和可视化。

1. model.train()

model.train()的作用是启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。

2. model.eval()

model.eval()的作用是不启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。

训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质

（2）获取结果：

六、结果可视化

可见准确率越来越高，损失越来越小

七、知识点详解

本文使用的是最简单的CNN模型，如果是第一次接触深度学习的话，可以先试着把代码跑通，然后再尝试去理解其中的代码。

1. MNIST手写数字数据集介绍

MNIST手写数字数据集来源于是美国国家标准与技术研究所，是著名的公开数据集之一。数据集中的数字图片是由250个不同职业的人纯手写绘制，数据集获取的网址为：MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges（下载后需解压）。我们一般会采用(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()这行代码直接调用，这样就比较简单

MNIST手写数字数据集中包含了70000张图片，其中60000张为训练数据，10000为测试数据，70000张图片均是28*28，数据集样本如下：

如果我们把每一张图片中的像素转换为向量，则得到长度为28*28=784的向量。因此我们可以把训练集看成是一个[60000,784]的张量，第一个维度表示图片的索引，第二个维度表示每张图片中的像素点。而图片里的每个像素点的值介于0-1之间。

2. 神经网络程序说明

神经网络程序可以简单概括如下：

八、总结

PyTorch是一个开源的机器学习库，在使用pytorch构建网络时候，就像插积木一样，灵活拓展性很好，pytorch也便于安装使用，只需一行代码即可安装。在本周的深度学习案例中，我了解到了一个分类任务的基本构成，数据集是必须的，是第一步，本次案例采用开源数据集，dateset直接下载即可，然后进行划分训练集和测试集dateloder加载，为方便查看，使用了绘图进行可视化，第二步构建网络，对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类，卷积层池化层提取到图片特征后，全连接层进行分类得出结果，第三步就是训练模型了，迭代训练模型。它使用损失函数计算模型预测与实际标签之间的损失，并使用优化器根据损失函数计算的梯度来更新模型的参数，以使损失函数的值最小化。根据损失值进行参数更新，同时记录训练过程中的准确率和损失值。通过多次迭代训练，模型可以逐渐优化并提高在训练数据上的性能。训练结束后，同理编写测试函数，但是不需要传入优化器，最后定义轮数进行正式训练，获取结果，最后根据准确率和损失值可视化绘图查看结果，以此来评价模型。整体下来就这几步，有了清晰的了解。数据集，构建网络，训练模型，得出结果。最后，欢迎大家批评指正，感谢K同学。