模型建立代码#

LeNet包含如下层：

二维卷积层 $([32,32] \rightarrow [6,28,28])$ ，激活函数 $relu$
池化层 $(\rightarrow [6,14,14])$
二维卷积层 $(\rightarrow [16,10,10])$ ，激活函数 $relu$
池化层 $(\rightarrow [16,5,5])$
打平向量 $(\rightarrow [16*5*5])$
全连接层 $(\rightarrow [120])$ ，激活函数 $relu$
全连接层 $(\rightarrow [84])$ ，激活函数 $relu$
全连接层 $(\rightarrow [10])$

1
import torch
2
import torch.nn as nn
3
import torch.nn.functional as F
4

5
class Net(nn.Module):
6
    def __init__(self):
7
        super(Net, self).__init__()
8
        # 1 维输入图像通道，6 维输出通道
9
        # 卷积核为 5x5 的卷积核
10
        self.conv1 = nn.Conv2d(1, 6, 5)
11
        # 6 维输入图像通道，16 维输出通道
12
        # 卷积核为 5x5 的卷积核
13
        self.conv2 = nn.Conv2d(6, 16, 5)
14

15
        # 最后的三层全连接
16
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
17
        self.fc2 = nn.Linear(120, 84)
18
        self.fc3 = nn.Linear(84, 10)
19

20
    def forward(self, x):
21
        # 用 2x2 的窗口对第一层卷积进行 Max pooling池化操作
22
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
23
        # 对第二层卷积进行同样操作
24
        # 如果池化窗口形状为正方形，可以只输入一个数
25
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
26

27
        # 将 x 打平成一维向量
28
        x = x.view(-1, self.num_flot_features(x))
29

30
        # 全连接层的前向传播
31
        x = F.relu(self.fc1(x))
32
        x = F.relu(self.fc2(x))
33
        x = self.fc3(x)
34
        return x
35

36
    def num_flot_features(self, x):
37
        """
38
        计算除批次外的所有维度
39
        用来确定打平后的维度
40
        如 x.shape = [100, 28, 28]
41
        返回值为 28 * 28
42

43
        :param x: 数据
44
        :return: 除第一维外的所有维度之积
45
        """
46
        size = x.size()[1:]
47
        num_features = 1
48
        for s in size:
49
            num_features *= s
50

51
        return num_features

输出网络结构#

可以通过打印对象直接查看构成网络的各层属性。

示例代码：

1
# 创建LetNet对象
2
net = Net()
3
# 输出网络结构
4
print('网络结构：\n', net)

输出结果：

1
网络结构：
2
 Net(
3
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
4
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
5
  (fc1): Linear(in_features=400, out_features=120, bias=True)
6
  (fc2): Linear(in_features=120, out_features=84, bias=True)
7
  (fc3): Linear(in_features=84, out_features=10, bias=True)
8
)

查看可训练参数#

可以通过 .parameters() 获得各层参数，可用来更新权重。

示例代码：

1
# 创建LetNet对象
2
net = Net()
3

4
# 使用 net.parameters 可以获得被学习参数的列表和值
5
params = list(net.parameters())
6

7
print('需训练的参数矩阵个数：', len(params))
8

9
for p in params:
10
    print(p.size())

输出结果：

1
需训练的参数矩阵个数： 10
2
torch.Size([6, 1, 5, 5]) # 第一层卷积核的参数
3
torch.Size([6]) # 第一层卷积核的偏置
4
torch.Size([16, 6, 5, 5]) # 第二层卷积核的参数
5
torch.Size([16]) # 第二层卷积核的偏置
6
torch.Size([120, 400]) # 第一次全连接的权重
7
torch.Size([120]) # 第一层全连接的偏置
8
torch.Size([84, 120]) # 第二层全连接的权重
9
torch.Size([84]) # 第二层全连接的偏置
10
torch.Size([10, 84]) # 第三层全连接的权重
11
torch.Size([10]) # 第三层全连接的偏置

前向传播#

使用 对象名(输入数据)来进行前向计算。

示例代码：

1
# 创建LetNet对象
2
net = Net()
3

4
# 表示为：有1批数量为1的32*32大小的图片
5
input_ = torch.randn(1, 1, 32, 32)
6
out = net(input_)
7
print('网络输出：', out)

输出结果：

1
网络输出： tensor([[-0.0573, -0.0214, -0.0619,  0.0998,  0.0441, -0.0282,  0.0089,  0.0991,
2
         -0.0603, -0.0076]], grad_fn=<AddmmBackward>)

反向传播和梯度下降#

可以用过 loss.backward() 来更新梯度，然后用 net.parameters() 来获取并更新参数。

示例代码：

1
# 创建LetNet对象
2
net = Net()
3

4
# 创建 X
5
# 表示为：有1批数量为1的32*32大小的图片
6
x = torch.randn(1, 1, 32, 32)
7

8
# 创建 Y
9
y = torch.randn(1,10)
10

11
# 前向计算
12
y_pred = net(x)
13

14
# 设置损失函数为 MSE
15
loss_func = nn.MSELoss()
16

17
# 计算损失
18
loss = loss_func(y_pred, y)
19
print('梯度下降前loss:', loss)
20

21
# 输出第一层卷积在反向传播前的梯度
22
print('conv1.bias.gard 反向传播前:', net.conv1.bias.grad)
23

24
# 进行反向传播
25
loss.backward()
26

27
# 输出反向传播后的梯度
28
print('conv1.bias.gard 反向传播后:', net.conv1.bias.grad)
29

30
# 更新权重
31
learning_rate = 1 # 设置学习率为 1，是为了加快权重变化
32
for p in net.parameters():
33
  # 更新参数
34
    # w = w - lr * w_grad
35
    p.data.sub_(p.grad.data * learning_rate)
36

37
# 再次计算结果和损失
38
y_pred = net(x)
39
loss = loss_func(y_pred, y)
40
print('梯度下降后loss:', loss)

输出结果：

1
梯度下降前loss: tensor(0.7424, grad_fn=<MseLossBackward>)
2
conv1.bias.gard 反向传播前: None
3
conv1.bias.gard 反向传播后: tensor([ 0.0236, -0.0085,  0.0035, -0.0035, -0.0115, -0.0085])
4
梯度下降后loss: tensor(0.0246, grad_fn=<MseLossBackward>)

优化器#

若想使用一些经典的优化器来进行权重更新，可在 torch.optim 中快速调用。

通过optimzer = optim.SGD(net.parameters(), lr=1) 的方式绑定参数。然后在反向传播后通过 optimzer.step() 来更新梯度。

示例代码：

1
import torch.optim as optim
2

3
net = Net()
4

5
# 设置优化器
6
optimzer = optim.SGD(net.parameters(), lr=1)
7

8
# 计算梯度
9
x = torch.randn(1, 1, 32, 32)
10
y = torch.randn(1,10)
11
y_pred = net(x)
12
loss_func = nn.MSELoss()
13
loss = loss_func(y_pred, y)
14
print('梯度下降前loss:', loss)
15
loss.backward()
16

17
# 更新梯度
18
optimzer.step()
19

20
# 再次预测
21
y_pred = net(x)
22
loss = loss_func(y_pred, y)
23
print('梯度下降后loss:', loss)

输出结果：

1
梯度下降前loss: tensor(1.0159, grad_fn=<MseLossBackward>)
2
梯度下降后loss: tensor(0.0834, grad_fn=<MseLossBackward>)

关于 zero_grad#

.zero_gard() 用来清理累计的梯度，可以使用形如 net.zero_gard() 或 optimzer.zero_gard() 的代码来使用。但由于上面代码都只进行了一次梯度下降，且经过尝试发现删除有关 .zero_gard() 的代码并不会产生什么影响。为了让自己对 pytorch 的理解更透彻，删除了可能没有对结果产生影响的代码。当在后续学习中，出现此代码必不可少的情况时，再对其功能进行学习研究。

原文链接：CSDN