使用pytorch构建一个简单的神经网络

网络的搭建

首先，我们创造一个继承于类 nn.Module 下的类 Net，并在初始化时就定义网络的结构。我们构建出两层卷积层和三个全连接层作为例子

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 3x3 square convolution kernel
        self.conv1 = nn.Conv2d(1, 6, 3, padding=1)
        self.conv2 = nn.Conv2d(6, 16, 3, padding=1)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

在这里，我们相当于构建出了网络的基本框架。在这之后，我们即可以着手搭建整个网络

x = F.max_pool2d(F.relu(self.conv1(x)), 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)

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

像之前说的那样，卷积层池化层等基本结构都可以传入输入的基本参数，于是当我们给出输入的时候，我们就可以得到对应的全连接层输出。
对于此示例网络，例如给出 (1, 1, 32, 32) 的单通道 32*32 大小的单张图片，我们将得到以以下顺序执行的网络：
(1, 1, 32, 32) -> (1, 6, 16, 16) -> (1, 16, 8, 8)
(1, 1024) -> (1, 120) -> (1, 84) -> (1, 10)

网络的使用

在入口函数中，我们先实例化网络，在这之后，我们得到网络中所有需要的参数。这个可以通过简单的函数得到：

params = list(net.parameters())

这个函数中，我们可以得到 pytorch 为卷积核自动分配的空间，例如在(1, 1, 32, 32) -> (1, 6, 16, 16) 这个步骤中，分配的空间为 (6, 1, 3, 3)。也就是6个切片部分（深度为6）；每个切片的深度为6， 切片的宽高即为卷积核宽高，为3，3。例如：

print(params[0].size())
# torch.Size([6, 1, 3, 3])
print(params[2].size())
# torch.Size([16, 6, 3, 3])

这时我们将输入定为 (1, 1, 32, 32)，即可得到最后的结果为：

input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
# torch.Size([1, 10])

在这之后，我们要做的就是使用反向传播、计算代价并更新权重。在pytorch中，有很多代价函数的计算方法，其中出镜率较高的则是 L2正则化。我们依照官方文档给出的样例进行更改后得到反向传播的计算方法，也就是 nn.MSELoss()

# 给出最原始的输入部分
input = Variable(torch.randn(1, 1, 32, 32), requires_grad=True)
# 原始输入输入进网络中
output = net(input)
# 给出收敛目标
target = Variable(torch.randn(1, 10))
# 确定以L2正则化方式为代价计算方法
criterion = nn.MSELoss()
# 根据输入和目标计算损失
loss = criterion(output, target)
# 进行反向传播
loss.backward()
# 对反向传播的结果进行测试
print(net.conv1.weight.grad)
print(net.conv2.bias.grad)

这样，我们就完成了第一遍的反向传播。这时我们要做的就剩下更新网络的权重以达到训练的效果。
我们使用 pytorch 自带的 torch.optim 包中的优化方法来对网络中的参数进行优化，具体方法十分简洁：

# 创建优化目标，lr是学习率
optimizer = optim.SGD(net.parameters(), lr=0.01)
# 进行优化
optimizer.step()

这样，我们就完成了一个简单的神经网络，全部代码为：
注：保证安装 torch 和 torchvision，安装教程为
点我安装

import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 3, padding=1)
        self.conv2 = nn.Conv2d(6, 16, 3, padding=1)
        self.fc1 = nn.Linear(16 * 8 * 8, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), 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:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


if __name__ == "__main__":
    net = Net()
    params = list(net.parameters())
    input = Variable(torch.randn(1, 1, 32, 32), requires_grad=True)
    optimizer = optim.SGD(net.parameters(), lr=0.01)
    output = net(input)
    target = Variable(torch.randn(1, 10))
    criterion = nn.MSELoss()
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()