简单的神经网络构建

神经网络可以通过torch.nn来构建。

现在对于自动梯度(autograd)有一些了解，神经网络是基于自动梯度 (autograd)来定义一些模型。一个 nn.Module包括：层和一个方法 forward(input) 它会返回输出(output)。

一个典型的神经网络训练过程包括以下几点：

  1. 定义一个包含可训练参数的神经网络
  2. 迭代整个输入
  3. 通过神经网络处理输入
  4. 计算损失（LOSS）
  5. 反向传播梯度到神经网络的参数
  6. 更新网络的参宿和，典型的用一个简单的更新方法：weight = weight - learning rate * gradient

第一步：神经网络构建

不可缺少的部分：

  • def __init__(self)：初始化网络架构：卷积层、池化层、激活函数、全连接层等等
  • def forward(self,x)：前向传播：连接各个层
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 输入通道, 6 输出通道, 5x5 卷积核
       # 卷积层
       self.conv1 = nn.Conv2d(1, 6, 5)
       self.conv2 = nn.Conv2d(6, 16, 5)
       # 一个仿射操作: 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):
       # 最大池化 (2, 2) 窗口
       x = 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 x

   def num_flat_features(self, x):
       size = x.size()[1:]  # 除了批次维度以外的所有维度
       num_features = 1
       for s in size:
           num_features *= s
       return num_features


net = Net()
print(net)

注释一：查看可训练参数列表

  • net.parameters保存网络中可训练的参数
  • 输出顺序：先输出 weight 后输出 bias 交替输出。下图为第一层卷积层相关参数
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QvCbKID0-1639280714789)(./params_weight.png)]
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m7xCOZ6C-1639280714791)(./params_bias.png)]
params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1的权重

第二步：处理输入并调用反向传播

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
net.zero_grad()
out.backward(torch.randn(1, 10))

第三步：计算损失值并进行反向传播

为了实现反向传播损失，我们所有需要做的事情仅仅是使用 loss.backward()。你需要清空现存的梯度，要不然帝都将会和现存的梯度累计到一起。

output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

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)

注释二：计算图

如果你跟随损失到反向传播路径，可以使用它的 .grad_fn属性，你将会看到一个这样的计算图

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

第五步：更新权重值

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

注释三：其他更新规则

如果你是用神经网络，你想使用不同的更新规则，类似于 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()    # 确认更新