PyTorch 笔记Ⅲ——PyTorch 神经网络
文章目录
- Neural Networks
-
- 定义网络
- 损失函数
- 反向传播
- 更新权重
- PyTorch 基础 : 神经网络包nn和优化器optm
-
- 定义一个网络
- 损失函数
- 优化器
Neural Networks
使用torch.nn包来构建神经网络。
上一讲已经讲过了autograd，nn包依赖autograd包来定义模型并求导。
一个nn.Module包含各个层和一个forward(input)方法，该方法返回output。
例如：
它是一个简单的前馈神经网络，它接受一个输入，然后一层接着一层地传递，最后输出计算的结果。
神经网络的典型训练过程如下：
- 定义包含一些可学习的参数(或者叫权重)神经网络模型；
- 在数据集上迭代；
- 通过神经网络处理输入；
- 计算损失(输出结果和正确值的差值大小)；
- 将梯度反向传播回网络的参数；
- 更新网络的参数，主要使用如下简单的更新原则：
weight = weight - learning_rate * gradient
定义网络
开始定义一个网络：
import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 1 input image channel, 6 output channels, 5x5 square convolution
# kernel
self.conv1 = nn.Conv2d(1, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
# Max pooling over a (2, 2) window
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:] # all dimensions except the batch dimension
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
print(net)
Net(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
在模型中必须要定义 forward 函数【前向传播】，backward
函数【反向传播】（用来计算梯度）会被autograd自动创建。
可以在 forward 函数中使用任何针对 Tensor 的操作。
net.parameters()返回可被学习的参数（权重）列表和值，所展示的网络一共有10个批量的参数，其中包括(conv1)(conv2)(fc1)(fc2)(fc3)5个以及其对应的偏置bias
params = list(net.parameters())
print(len(params))
for i in range(len(params)):
print(params[i].size())
10
torch.Size([6, 1, 5, 5])
torch.Size([6])
torch.Size([16, 6, 5, 5])
torch.Size([16])
torch.Size([120, 400])
torch.Size([120])
torch.Size([84, 120])
torch.Size([84])
torch.Size([10, 84])
torch.Size([10])
测试随机输入32×32。
注：这个网络（LeNet）期望的输入大小是32×32，如果使用MNIST数据集来训练这个网络，请把图片大小重新调整到32×32。
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
tensor([[-0.0261, 0.0512, -0.0273, 0.0461, 0.0424, -0.0950, -0.1196, 0.0236,
0.0636, 0.0366]], grad_fn=)
将所有参数的梯度缓存清零，然后进行随机梯度的的反向传播：
net.zero_grad()
out.backward(torch.randn(1, 10))
Note
``torch.nn`` 只支持小批量输入。整个 ``torch.nn`` 包都只支持小批量样本，而不支持单个样本。
例如，``nn.Conv2d`` 接受一个4维的张量，
``每一维分别是sSamples * nChannels * Height * Width（样本数*通道数*高*宽）``。
如果你有单个样本，只需使用 ``input.unsqueeze(0)`` 来添加其它的维数
在继续之前，我们回顾一下到目前为止用到的类。
回顾:
torch.Tensor：一个用过自动调用backward()实现支持自动梯度计算的 多维数组 ，
并且保存关于这个向量的梯度w.r.t.nn.Module：神经网络模块。封装参数、移动到GPU上运行、导出、加载等。nn.Parameter：一种变量，当把它赋值给一个Module时，被自动地注册为一个参数。autograd.Function：实现一个自动求导操作的前向和反向定义，每个Tensor操作都会创建至少一个Function节点，该节点连接到创建Tensor并对其历史进行编码的函数。
重点如下：
- 定义一个网络
- 处理输入，调用backword
还剩：
- 计算损失
- 更新网络权重
损失函数
一个损失函数接受一对 (output, target) 作为输入，计算一个值来估计网络的输出和目标值相差多少。
译者注：output为网络的输出，target为实际值
nn包中有很多不同的损失函数。
nn.MSELoss是一个比较简单的损失函数，它计算输出和目标间的均方误差，
例如：
output = net(input)
target = torch.randn(10) # 随机值作为样例
target = target.view(1, -1) # 使target和output的shape相同
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)
tensor(1.3120, grad_fn=)
现在，如果在反向过程中跟随loss ， 使用它的
.grad_fn 属性，将看到如下所示的计算图。
input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss
所以，当我们调用 loss.backward()时,整张计算图都会
根据loss进行微分，而且图中所有设置为requires_grad=True的张量
将会拥有一个随着梯度累积的.grad 张量。
为了演示，我们将跟随以下步骤来反向传播
print(loss.grad_fn) # MSELoss
print(loss.grad_fn.next_functions[0][0]) # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU
反向传播
调用loss.backward()获得反向传播的loss
但是在调用前需要清除已存在的梯度，否则梯度将被累加到已存在的梯度。
现在，我们将调用loss.backward()，并查看conv1层的偏差（bias）项在反向传播前后的梯度。
net.zero_grad() # 清除梯度
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)
conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([-0.0167, 0.0023, -0.0038, 0.0038, 0.0047, 0.0055])
更新权重
在实践中最简单的权重更新规则是随机梯度下降（SGD）：
weight = weight - learning_rate * gradient
我们可以使用简单的Python代码实现这个规则：
learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)
但是当使用神经网络是想要使用各种不同的更新规则时，比如SGD、Nesterov-SGD、Adam、RMSPROP等，PyTorch中构建了一个包torch.optim实现了所有的这些规则
import torch.optim as optim
# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)
# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update
注意:
观察如何使用optimizer.zero_grad()手动将梯度缓冲区设置为零
这是因为梯度是按Backprop部分中的说明累积的
PyTorch 基础 : 神经网络包nn和优化器optm
torch.nn是专门为神经网络设计的模块化接口。nn构建于 Autograd之上，可用来定义和运行神经网络。
这里我们主要介绍几个一些常用的类
约定：torch.nn 我们为了方便使用，会为他设置别名为nn，本章除nn以外还有其他的命名约定
# 首先要引入相关的包
import torch
# 引入torch.nn并指定别名
import torch.nn as nn
#打印一下版本
torch.__version__
'1.6.0'
除了nn别名以外，我们还引用了nn.functional，这个包中包含了神经网络中使用的一些常用函数，这些函数的特点是，不具有可学习的参数(如ReLU，pool，DropOut等)，这些函数可以放在构造函数中，也可以不放，但是这里建议不放。
一般情况下我们会将nn.functional 设置为大写的F，这样缩写方便调用
import torch.nn.functional as F
定义一个网络
PyTorch中已经为我们准备好了现成的网络模型，只要继承nn.Module，并实现它的forward方法，PyTorch会根据autograd，自动实现backward函数，在forward函数中可使用任何tensor支持的函数，还可以使用if、for循环、print、log等Python语法，写法和标准的Python写法一致。
class Net(nn.Module):
def __init__(self):
# nn.Module子类的函数必须在构造函数中执行父类的构造函数
super(Net, self).__init__()
# 卷积层 '1'表示输入图片为单通道， '6'表示输出通道数，'3'表示卷积核为3*3
self.conv1 = nn.Conv2d(1, 6, 3)
#线性层，输入1350个特征，输出10个特征
self.fc1 = nn.Linear(1350, 10) #这里的1350是如何计算的呢？这就要看后面的forward函数
#正向传播
def forward(self, x):
print(x.size()) # 结果：[1, 1, 32, 32]
# 卷积 -> 激活 -> 池化
x = self.conv1(x) #根据卷积的尺寸计算公式，计算结果是30，具体计算公式后面第二章第四节 卷积神经网络 有详细介绍。
x = F.relu(x)
print(x.size()) # 结果：[1, 6, 30, 30]
x = F.max_pool2d(x, (2, 2)) #我们使用池化层，计算结果是15
x = F.relu(x)
print(x.size()) # 结果：[1, 6, 15, 15]
# reshape，‘-1’表示自适应
#这里做的就是压扁的操作 就是把后面的[1, 6, 15, 15]压扁，变为 [1, 1350]
x = x.view(x.size()[0], -1)
print(x.size()) # 这里就是fc1层的的输入1350
x = self.fc1(x)
return x
net = Net()
print(net)
Net(
(conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
(fc1): Linear(in_features=1350, out_features=10, bias=True)
)
网络的可学习参数通过net.parameters()返回
for parameters in net.parameters():
print(parameters)
Parameter containing:
tensor([[[[-0.0655, -0.2152, -0.0209],
[ 0.2389, 0.1121, -0.2018],
[-0.1230, -0.1481, 0.2385]]],
[[[ 0.2534, 0.2113, 0.0749],
[ 0.0016, 0.1679, -0.2298],
[ 0.2790, 0.1082, 0.2883]]],
[[[ 0.2587, 0.2425, -0.1423],
[-0.3084, -0.1680, -0.1456],
[-0.1978, -0.2841, 0.2454]]],
[[[ 0.2025, -0.0797, 0.2681],
[ 0.1655, -0.2278, 0.1420],
[ 0.3147, -0.2786, 0.0260]]],
[[[ 0.1499, -0.2650, -0.3023],
[ 0.2920, 0.1875, 0.0542],
[-0.0699, 0.0901, 0.2694]]],
[[[-0.0859, 0.1209, -0.1765],
[-0.0578, -0.2773, 0.3333],
[ 0.1736, -0.2491, 0.2661]]]], requires_grad=True)
Parameter containing:
tensor([ 0.2215, -0.2372, -0.0626, -0.0844, -0.2688, -0.2503],
requires_grad=True)
Parameter containing:
tensor([[-0.0157, -0.0119, 0.0110, ..., -0.0169, -0.0019, -0.0030],
[-0.0061, -0.0247, 0.0173, ..., -0.0119, 0.0126, 0.0070],
[ 0.0023, 0.0265, 0.0095, ..., -0.0127, 0.0145, -0.0018],
...,
[ 0.0118, -0.0121, 0.0083, ..., -0.0152, -0.0137, 0.0248],
[ 0.0245, -0.0099, -0.0234, ..., 0.0144, -0.0187, 0.0006],
[ 0.0219, -0.0175, -0.0258, ..., 0.0201, -0.0207, 0.0183]],
requires_grad=True)
Parameter containing:
tensor([-0.0207, 0.0241, -0.0180, 0.0212, 0.0186, -0.0192, 0.0178, 0.0102,
0.0245, -0.0154], requires_grad=True)
net.named_parameters可同时返回可学习的参数及名称。
for name,parameters in net.named_parameters():
print(name,':',parameters.size())
conv1.weight : torch.Size([6, 1, 3, 3])
conv1.bias : torch.Size([6])
fc1.weight : torch.Size([10, 1350])
fc1.bias : torch.Size([10])
forward函数的输入和输出都是Tensor
input = torch.randn(1, 1, 32, 32) # 这里的对应前面fforward的输入是32
out = net(input)
out.size()
torch.Size([1, 1, 32, 32])
torch.Size([1, 6, 30, 30])
torch.Size([1, 6, 15, 15])
torch.Size([1, 1350])
torch.Size([1, 10])
input.size()
torch.Size([1, 1, 32, 32])
在反向传播前，先要将所有参数的梯度清零
net.zero_grad()
out.backward(torch.ones(1,10)) # 反向传播的实现是PyTorch自动实现的，我们只要调用这个函数即可
注意:torch.nn只支持mini-batches，不支持一次只输入一个样本，即一次必须是一个batch。
也就是说，就算我们输入一个样本，也会对样本进行分批，所以，所有的输入都会增加一个维度，我们对比下刚才的input，nn中定义为3维，但是我们人工创建时多增加了一个维度，变为了4维，最前面的1即为batch-size
损失函数
在nn中PyTorch还预制了常用的损失函数，下面我们用MSELoss用来计算均方误差
y = torch.arange(0,10).view(1,10).float()
criterion = nn.MSELoss()
loss = criterion(out, y)
#loss是个scalar，我们可以直接用item获取到他的python类型的数值
print(loss.item())
29.15236473083496
优化器
在反向传播计算完所有参数的梯度后，还需要使用优化方法来更新网络的权重和参数，例如随机梯度下降法(SGD)的更新策略如下：
weight = weight - learning_rate * gradient
在torch.optim中实现大多数的优化方法，例如RMSProp、Adam、SGD等，下面我们使用SGD做个简单的样例
import torch.optim
out = net(input) # 这里调用的时候会打印出我们在forword函数中打印的x的大小
criterion = nn.MSELoss()
loss = criterion(out, y)
#新建一个优化器，SGD只需要要调整的参数和学习率
optimizer = torch.optim.SGD(net.parameters(), lr = 0.01)
# 先梯度清零(与net.zero_grad()效果一样)
optimizer.zero_grad()
loss.backward()
#更新参数
optimizer.step()
torch.Size([1, 1, 32, 32])
torch.Size([1, 6, 30, 30])
torch.Size([1, 6, 15, 15])
torch.Size([1, 1350])
这样，神经网络的数据的一个完整的传播就已经通过PyTorch实现了，下面一章将介绍PyTorch提供的数据加载和处理工具，使用这些工具可以方便的处理所需要的数据。
看完这节，大家可能对神经网络模型里面的一些参数的计算方式还有疑惑，这部分会在第二章 第四节 卷积神经网络有详细介绍，并且在第三章 第二节 MNIST数据集手写数字识别的实践代码中有详细的注释说明。
参考链接：PyTorch官方教程中文版
参考链接：yunjey-pytorch-tutorial