pytorch教程-1. 构建神经网络

pytorch中所有神经网络的核心是autograd包，autograd包为张量上的所有操作提供了自动求导的机制，它是一个在运行时定义的框架，这意味着反向传播是根据代码如何运行来决定的，并且每次迭代可以是不同的。

张量

• torch.tensor是这个包的核心类，如果设置它的属性.required _grad=True,那么它将会追踪对于该张量的所有操作，当完成计算时可以通过调用.backward(),来自动计算所有的梯度。这个张量的所有梯度将会被自动累加到.grad属性。如果要阻止一个张量被追踪，可以调用.detach()方法将其与计算历史分离，并组织它未来的计算被追踪。为了防止追踪历史记录和使用内存，可以将代码块包装在with torch.no_grad():中，在评估模型时特别有用。
• 还有一个类对于autograd的实现非常重要：Function。tensor和Function互相连接，编码了完整的计算历史，每个张量都有一个.grad_fn 属性，该属性引用了创建tensor自身的Function
• 代码演示

import torch
x=torch.ones(2,2,requires_grad=True)
print(x)
y=x+2
print(y)
print(y.grad_fn)
a=torch.randn(2,2)
a=((a*3)/(a-1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)

tensor([[1., 1.],[1., 1.]], requires_grad=True)
tensor([[3., 3.],[3., 3.]], grad_fn=<AddBackward0>)
<AddBackward0 object at 0x000001F39E4BDD30>
False
True
<SumBackward0 object at 0x000001F39E4BDF98>

pytorch一般使用torch.nn来构建神经网络，nn包依赖于autograd包来定义模型并对它们求导，一个nn.Module包含各个层和一个forward(input)方法，该方法返回output。
典型神经网络训练过程

• 定义包含权重的神经网络
• 在输入数据集上迭代
• 通过网络处理输入
• 计算loss
• 将梯度反向传播给网络的参数
• 更新网络参数weight = weight - learning_rate * gradient

定义网络

import torch
import torch.nn as nn
import torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()# 输入图像channel：1；输出channel：6；5x5卷积核self.conv1 = nn.Conv2d(1, 6, 5)self.conv2 = nn.Conv2d(6, 16, 5)# an affine operation: y = Wx + bself.fc1 = nn.Linear(16 * 5 * 5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)def forward(self, x):# 2x2 Max poolingx = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))# 如果是方阵,则可以只使用一个数字进行定义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 xdef num_flat_features(self, x):size = x.size()[1:]  # 除去批处理维度的其他所有维度num_features = 1for s in size:num_features *= sreturn num_featuresnet = 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时自动定义，backward函数用来计算导数。我们可以在 forward 函数中使用任何针对张量的操作和计算。
测试

params=list(net.parameters())
print(len(params))
print(params[1].size())
input=torch.rand(1,1,32,32)
out=net(input)
print(out)

10
torch.Size([6])
tensor([[ 0.0475, -0.0317,  0.0667, -0.0221, -0.0535, -0.0424, -0.0987,  0.0406,0.0520, -0.1062]], grad_fn=<AddmmBackward>)

损失函数

input=torch.randn(1,1,32,32)
output = net(input)
print(output.shape)
target = torch.randn(10)  # 本例子中使用模拟数据
target = target.view(1, -1)  # 使目标值与数据值尺寸一致
print(target.shape)
criterion = nn.MSELoss()loss = criterion(output, target)
print(loss)
print(loss.grad_fn)

torch.Size([1, 10])
torch.Size([1, 10])
tensor(1.4566, grad_fn=<MseLossBackward>)
<MseLossBackward object at 0x000001F39E500780>

此时如果使用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属性开始积累梯度张量。注意forward过程只是定义了计算图，在运行loss.backward()之后梯度才开始计算。
反向传播
我们只需要调用loss.backward()来反向传播误差。我们需要清零现有的梯度，否则梯度将会与已有的梯度累加。
现在，我们将调用loss.backward()，并查看conv1层的偏置(bias)在反向传播前后的梯度。

net.zero_grad()
print('conv1.bias.grad before backward:%s'%(net.conv1.bias.grad))
loss.backward()
print('conv1.bias.grad after backward:%s'%(net.conv1.bias.grad))

可以看见在没有调用backward之前梯度是没有计算的。

conv1.bias.grad before backward:tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward:tensor([ 0.0237,  0.0092,  0.0009,  0.0056, -0.0152,  0.0179])

更新权重
在使用神经网络时，可能希望使用各种不同的更新规则，如SGD、Nesterov-SGD、Adam、RMSProp等。torch.optim提供了一个很好的包，它实现了所有的这些方法。简单使用：

import torch.optim as optim
#创建优化器
optimizer=optim.SGD(net.parameters(),lr=0.01)
#在训练的迭代中
optimizer.zero_grad()#清零梯度，否则会梯度叠加
output=net(input)
loss=criterion(output,target)
loss.backward()
optimizer.step()#更新梯度参数

通过上述过程即可简单构建一个神经网络。