神经网络可以通过torch.nn包构建。
之前已经对torch.autograd包和Tensor包有个基本的认识。
- 通过
torch.nn模型来构建升级网络模型。 -
torch.nn包依赖于torch.autograd来构建神经网络模型并实现反向传播（梯度计算）。 -
nn.Module包含了神经网络各层的定义，通过foward(input)方法返回输出output。
Example
以下是一个对数字图像进行分类的神经网络结构（LeNet5）:
LeNet5网络结构
这是一个简单的前馈神经网络。结构一张32*32的图片作为输入，通过几个不同的网络层，最后得到输出。
经典的神经网络训练过程如下：
- 定义含有待学习参数（权重）的神经网络结构
- 数据集输入
- 处理输入数据，通过前向传播获得输出
- 计算损失值
- 更新网络的权重，最简单的更新规则：
weight = weight - learning_rate * gradient
定义神经网络
使用Pytorch来定义上图中的网络结构：
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
class LeNet(nn.Module):
def __init__(self):
super(LeNet,self).__init__()
# self.conv1 = nn.Conv2d(1,6,5) #
# self.mp = nn.max_pool2d(2,2)
# self.conv2 = nn.Conv2d()
self.conv1 = nn.Sequential(
nn.Conv2d(1,6,5),
nn.ReLU(),
nn.MaxPool2d((2,2))
)
self.conv2 = nn.Sequential(
nn.Conv2d(6,16,5),
nn.ReLU(),
nn.MaxPool2d((2,2))
)
self.fc1 = nn.Linear(16*5*5,120)
self.fc2 = nn.Linear(120,84)
self.fc3 = nn.Linear(84,10)
def forward(self,input): # (B，1，32，32)
print(input)
# 卷积=》池化
x = self.conv1(input)
x = self.conv2(x)
# 全连接
# x = x.view(input.size()[0],-1)
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 = LeNet()
print(net)
Output
模型的参数
- 我们只需要去定义前向传播(forward function)模型, 反向传播(backward)的过程在我们调用autograd的时候，自动生成。
- 你可以在forward的过程中使用任何Tensor操作。
- 通过
net.parameters()获得神经网络模型的所有参数
params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight
# 计算模型的参数总量
all_params = sum(p.numel() for p in net.parameters())
print(all_params)
结果
（6，1，5，5）和我们在模型中定义的结构相同
forward函数的输入与输出都是autograd.Variable类型的.
- 随记生成一个期望输入 32*32。测试模型的输出。
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
# 输出
tensor([[ 0.0158, -0.0394, 0.1107, 0.1668, 0.1236, 0.0622, -0.0679, 0.0233,
0.0937, -0.1895]], grad_fn=<AddmmBackward>)
输出了十个评分值，和我们的预期输出相同
- 所有参数的梯度清零，并且以随记初始值进行反向传播
net.zero_grad()
out.backward(torch.randn(1, 10))
注意点
- torch.nn包仅支持对批量数据的处理,而不能对单个样本进行处理。当你需要对单个数据进行处理的时候，使用input.unsqueeze(0)来增加假的batch维度。
- nn.Conv2()的输出为 (Batch, Channels, Height,Weight)
损失函数(Loss Function)
output = net(input)
target = torch.randn(1,10) # a dummy target, for example
criterion = nn.MSELoss() # 均方误差
loss = criterion(output, target)
print(loss)
# 输出
tensor(0.3994, grad_fn=<MseLossBackward>)
沿着loss的反向传播方向，依次用.grad_fn属性，就可以得到如下所示的计算图．
input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss
所以当我们调用loss.backward()函数的时候，整张图都被一次计算误差，所有Variable的.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
#输出
<MseLossBackward object at 0x1289a0e90>
<AddmmBackward object at 0x1289a0850>
<AccumulateGrad object at 0x1289a0e90>
反向传播(Backprop)
- 我们只需要通过
loss.backward来实现反向传播的过程 - 由于变量的梯度是累加的，所以在求backward之前应该先使用
net.zero_grad()或者optimizer.zero_grad()对现有的梯度清零
net.zero_grad() # zeroes the gradient buffers of all parameters
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.0182, 0.0073, -0.0004, 0.0235, -0.0043, 0.0060])
现在我们知道如何去使用损失函数，更多损失函数的信息可以前往：Pytorch文档 Loss Function
更新模型参数(权重)
- 最简单的参数更新方法(SGD):
lr = 0.0001
for f in net.parameters():
f.data.sub_(f.grad.data*lr)
- 为了满足不同的更新规则，比如 SGD, Nesterov-SGD, Adam, RMSProp等pttorch提供了一个很小的包：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
网友评论