【自学记录】【Pytorch2.0深度学习从零开始学 王晓华】第三章 基于Pytorch的MNIST分类实战

3.1.1 数据图像的获取与标签的说明

源码\第三章\one_hot.py

import numpy as np
import torch
x_train = np.load("../dataset/mnist/x_train.npy")
y_train_label = np.load("../dataset/mnist/y_train_label.npy")
print(y_train_label[:5]) #[5 0 4 1 9]
x = torch.tensor(y_train_label[:5],dtype=torch.int64)# 定义一个张量输入tensor([5, 0, 4, 1, 9])
y = torch.nn.functional.one_hot(x, 10)  # 一个参数张量x，10为类别数，y shape=(5,10)
print(x)
print(y)
#y: tensor([[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
#         [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
#         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
#         [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.1.4 基于pytorch的手写体识别的实现

源码\第三章\train.py

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0' #指定GPU编号
import torch
import numpy as np
from tqdm import tqdm

batch_size = 320                        #设定每次训练的批次数
epochs = 1024                           #设定训练次数

#device = "cpu"                         #Pytorch的特性，需要指定计算的硬件，如果没有GPU的存在，就使用CPU进行计算
device = "cuda"                         #在这里读者默认使用GPU，如果读者出现运行问题可以将其改成cpu模式


#设定的多层感知机网络模型
class NeuralNetwork(torch.nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = torch.nn.Flatten() # 展平操作，将图片数据展平为一维  
        self.linear_relu_stack = torch.nn.Sequential(
            torch.nn.Linear(28*28,312),
            torch.nn.ReLU(),
            torch.nn.Linear(312, 256),
            torch.nn.ReLU(),
            torch.nn.Linear(256, 10)
        )
    def forward(self, input):
        x = self.flatten(input)
        logits = self.linear_relu_stack(x)

        return logits

model = NeuralNetwork()
model = model.to(device)                #将计算模型传入GPU硬件等待计算
torch.save(model, './model.pth')
#model = torch.compile(model)            #Pytorch2.0的特性，加速计算速度
loss_fu = torch.nn.CrossEntropyLoss()# 交叉熵损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=2e-5) #设定Adam优化器，学习率为2e-5

#载入数据
x_train = np.load("../dataset/mnist/x_train.npy")
y_train_label = np.load("../dataset/mnist/y_train_label.npy")

train_num = len(x_train)//batch_size

#开始计算
for epoch in range(epochs):#epochs
    train_loss = 0
    for i in range(train_num):
        start = i * batch_size #计算开始和终止位置，第一次是[0,batch_size-1)，第二2次[batch_size,2*batch_size)
        end = (i + 1) * batch_size

        #将数据转换为张量并移到指定设备  
        train_batch = torch.tensor(x_train[start:end]).to(device) 
        label_batch = torch.tensor(y_train_label[start:end]).to(device)

        pred = model(train_batch)#前向传播，得到预测结果
        loss = loss_fu(pred,label_batch)#计算损失

        optimizer.zero_grad()#清零梯度
        loss.backward()#反向传播，计算梯度  
        optimizer.step()# 更新模型参数  

        train_loss += loss.item()  # 记录每个批次的损失值

    # 计算并打印平均损失值
    train_loss /= train_num
    accuracy = (pred.argmax(1) == label_batch).type(torch.float32).sum().item() / batch_size
    print("epoch：",epoch,"train_loss:", round(train_loss,2),"accuracy:",round(accuracy,2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

结果：把批次改为epochs后（源码给的是20）就能持续训练了，到270次精确度就=1了。


需要补充的知识点（来自文心老师）：

1、PyTorch中常见的操作和概念：

张量（Tensor）：PyTorch中的基本数据结构，类似于多维数组，可以存储不同类型的数据（如浮点数、整数等）。
自动微分（Autograd）：PyTorch提供了自动微分功能，可以自动计算张量操作的梯度，这对于神经网络的训练非常重要。
神经网络层（Neural Network Layers）：PyTorch提供了许多预定义的神经网络层，如卷积层、全连接层、池化层等，用户可以轻松地组合这些层来构建自己的神经网络。
优化器（Optimizers）：用于更新神经网络参数的算法，如SGD（随机梯度下降）、Adam等。
数据加载器（Data Loaders）：用于从数据集中加载数据，并将其划分为批次（batches）进行训练或测试。

2、self.flatten = torch.nn.Flatten()

torch.nn.Flatten 是 PyTorch 中的一个模块，用于将多维的输入张量展平（flatten）成一维张量，或者展平到指定的维度。这在构建神经网络时特别有用，尤其是当你想要将图像数据（通常是二维或三维的）转换为一维特征向量，以便将其传递给全连接层（linear layers）时。
举例：

import torch  
import torch.nn as nn  
  
# 假设我们有一个四维张量，代表一批图像数据  
batch_size = 4  
channels = 3  
height = 28  
width = 28  
  
# 创建一个随机的四维张量来模拟图像数据  
images = torch.randn(batch_size, channels, height, width)  
  
# 定义一个包含 Flatten 层的简单模型  
class SimpleModel(nn.Module):  
    def __init__(self):  
        super(SimpleModel, self).__init__()  
        #############nn.Flatten()在这里使用###########################
        self.flatten = nn.Flatten()
          
    def forward(self, x):  
        x = self.flatten(x)  
        return x  
  
# 初始化模型  
model = SimpleModel()  
  
# 将图像数据传递给模型  
flattened = model(images)  
  
# 输出展平后的张量的形状  
print(flattened.shape)  # 输出应该是 (batch_size, -1)，其中 -1 表示自动计算的大小
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在这个例子中，nn.Flatten 会将形状为 (batch_size, channels, height, width) 的张量展平成一个形状为 (batch_size, -1) 的张量，其中 -1 是一个占位符，表示该维度的大小是自动计算的。实际上，-1 的大小会是 channels * height * width，即所有非批次维度的乘积。

对于 MNIST 数据集，图像通常是单通道的（灰度图），大小为 28x28 像素。因此，如果你有一个形状为 (batch_size, 1, 28, 28) 的张量，nn.Flatten 会将其展平为形状为 (batch_size, 784) 的张量（因为 1 * 28 * 28 = 784）。这样，你就可以将这个一维张量传递给全连接层进行进一步的处理了。

3、torch.nn.Sequential（）

torch.nn.Sequential 是 PyTorch 中的一个容器模块，它按照添加到其中的顺序依次包含多个子模块。当你向 Sequential 中添加模块时，它们将按照添加的顺序被依次执行。这种顺序执行使得 Sequential 非常适合于创建简单的、层叠式的神经网络结构。

使用 Sequential 的好处是它提供了一种简洁的方式来创建模型，而无需定义前向传播方法。你只需要将各个层添加到 Sequential 容器中，PyTorch 就会按照添加的顺序来执行这些层。

尽管 Sequential 对于简单的网络结构非常有用，但当你需要更复杂的控制流（如条件语句或循环）或需要定义自己的前向传播逻辑时，你可能需要定义自己的 nn.Module 子类，并在其中实现 forward 方法。

3.2.1 查看模型结构和参数信息

源码\第三章\netron.py

对于自定义网络，直接使用如下函数完成模型的打印：

model = NeuralNetwork()
print(model)
1
2

输出：

NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)#平滑成【1，X】大小
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=312, bias=True)#全连接层，接受784个输入特征，输出312个特征。bias=True表示这一层有偏置项。
    (1): ReLU()#这是ReLU激活函数，它应用于前一个线性层的输出。ReLU函数会将所有负值变为0，而正值保持不变。
    (2): Linear(in_features=312, out_features=256, bias=True)
    (3): ReLU()
    (4): Linear(in_features=256, out_features=10, bias=True)
  )
)
1
2
3
4
5
6
7
8
9
10

具体参数和层数的输出，有关net.parameters，参考此链接：

import torch
device = "cuda"                         #在这里读者默认使用GPU，如果读者出现运行问题可以将其改成cpu模式
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

#设定的多层感知机网络模型
class NeuralNetwork(torch.nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = torch.nn.Flatten()
        self.linear_relu_stack = torch.nn.Sequential(
            torch.nn.Linear(2,3),
            torch.nn.ReLU(),
            torch.nn.Linear(3, 5),
            torch.nn.ReLU(),
            torch.nn.Linear(5, 2)
        )
    def forward(self, input):
        x = self.flatten(input)
        logits = self.linear_relu_stack(x)

        return logits

model = NeuralNetwork()
#print(model)
model = model.to(device)                #将计算模型传入GPU硬件等待计算
# #torch.save(model, './model.pth')

params=list(model.parameters())
k=0
for num,para in enumerate(params):
    l=1
    print("第",num,"层的结构："+str(list(para.size())))
    for j in para.size():
        l*=j
    print("该层参数和："+str(l))
    print(para)
    print('______________________________')
    k=k+l
print("总参数数量和："+str(k))    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

输出：
其中，我们加上输出层一共设置了3层全连接层，对应以下第0、2、4层；第1、3层是偏置层。

还有一点，层的结构是[out,in],比如第一个 torch.nn.Linear(2,3)对应的层结构为[3, 2]。

第 0 层的结构：[3, 2]
该层参数和：6
Parameter containing:
tensor([[ 0.5712,  0.2243],
        [ 0.6914, -0.6446],
        [ 0.0275,  0.4616]], device='cuda:0', requires_grad=True)
______________________________
第 1 层的结构：[3]
该层参数和：3
Parameter containing:
tensor([0.1890, 0.0555, 0.6089], device='cuda:0', requires_grad=True)
______________________________
第 2 层的结构：[5, 3]
该层参数和：15
Parameter containing:
tensor([[ 0.4450,  0.3689,  0.5252],
        [ 0.4570,  0.1599, -0.4878],
        [ 0.2633,  0.4276, -0.5587],
        [-0.1436,  0.0929,  0.3933],
        [ 0.5510,  0.0286, -0.5658]], device='cuda:0', requires_grad=True)
______________________________
第 3 层的结构：[5]
该层参数和：5
Parameter containing:
tensor([ 0.2082, -0.0087,  0.3519, -0.3106,  0.0778], device='cuda:0',
       requires_grad=True)
______________________________
第 4 层的结构：[2, 5]
该层参数和：10
Parameter containing:
tensor([[ 0.0707, -0.0262, -0.2613,  0.1295, -0.1679],
        [-0.3952, -0.3387, -0.0963, -0.1872,  0.0991]], device='cuda:0',
       requires_grad=True)
______________________________
第 5 层的结构：[2]
该层参数和：2
Parameter containing:
tensor([-0.3942, -0.3752], device='cuda:0', requires_grad=True)
______________________________
总参数数量和：41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3.2.2 基于netron库的PyTorch2.0模型可视化