pytroch学习-神经网络

用torch.nn包构建神经网络

之前已经了解到了autograd，nn依赖于autograd来定义模型并进行求微分操作。nn.Module包含神经网络的各个层，方法forward(input) 返回 output

例如，观察下面用于分类手写识别数据的网络：

这是一个典型的前馈神经网络。它接受输入数据，将它逐层喂给网络，最后输出。

一个神经网络的训练过程如下：

• 定义具有若干可学习参数（权重）的神经网络结构。
• 在输入数据集上迭代
• 通过网络处理输入
• 计算损失值（度量输出与真实结果相差多远）
• 通过反向传播更新模型的参数
• 更新权重：weight=weight-learning_rate*gradient

定义网络

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        
        self.conv1 = nn.Conv2d(1, 6, 5) # 1 输入通道, 6输出通道, 5x5 的卷积核
        self.conv2 = nn.Conv2d(6, 16, 5)
        
        self.fc1 = nn.Linear(16 * 5 * 5, 120) # 仿射操作: y = Wx + b， 第一个参数是输入样本维度，第二个参数是输出样本的维度
        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, 2))  # 用(2, 2)的窗口做 Max pooling
        x = F.max_pool2d(F.relu(self.conv2(x)), 2) # If the size is a square you can only specify a single number

        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)

我们必须定义forward函数，而backward函数将会通过autograd自动定义。

模型中可学习的参数可以用net.parameters（）返回

paras=list(net.parameters())
print(len(paras))
print(paras[0].size())

让我们试一下一个32*32的随机输入

注意：这个网络（LeNet）的期望输入数据的格式是32*32。如果想输入MNIST数据集，请重分配数据的格式为32*32；

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

注意：torch.nn只支持mini-batch的数据形式，而不支持单个的数据

例如，nn.conv2d接受四维的参数nSamples*nChannels*Height*Width.如果你只有一个样本，用input.unsqueeze(0)加一个伪batch维度

到这里，我们再来回顾一下用到的类：

• torch.Tensor 多维数组，支持自动求导操作如backward()
• nn.Module 神经网络模块。封装参数的方便渠道，能够将运算移至GPU,还包括数据导出，导入等
• nn.Parameter 一种Tensor，当将任何值赋予Module时自动注册为一个参数
• autograd.Function 实现了使用自动求导方法的前馈和后馈的定义。每个Variable的操作都会生成至少一个独立的Function节点，与生成了Variable的函数相连之后记录下操作历史。

到这里我们已经定义了一个神经网络，处理了输入且调用了反向传播。接下来，还需要计算损失值，然后更新权重

损失函数

损失函数接受（output，target）的配对参数，计算网络的output与真实的target有多远的距离。nn包里有很多损失函数。一个简单的损失函数是nn.MSELoss,该函数计算output和target之间的均方误差。

例如：

out=net(input)
#print(out)
target=torch.arange(1,11)
target=target.view(1,-1)
criterion=nn.MSELoss()
loss=criterion(out,target)
print(loss)

更新权重

实践中最简单的权重更新规则是随机梯度下降（Stochastic Gradient Descent SGD）：

weight=weight-learning_rate*gradient

我们可以通过以下代码实现：

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

但是，当你使用神经网络时你希望使用不同的参数更新规则如SGD,Nestrov-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()