PyTorch基础（三）-----神经网络包nn和优化器optim

前言

torch.nn是专门为神经网络设计的模块化接口。nn构建于Autograd之上，可用来定义和运行神经网络。这里我们主要介绍几个一些常用的类。
约定：torch.nn 我们为了方便使用，会为他设置别名为nn，本章除nn以外还有其他的命名约定。

import torch
import torch.nn as nn
torch.__version__

除了nn别名以外，我们还引用了nn.functional，这个包中包含了神经网络中使用的一些常用函数，这些函数的特点是，不具有可学习的参数(如ReLU，pool，DropOut等)，这些函数可以放在构造函数中，也可以不放，但是这里建议不放。
一般情况下我们会将nn.functional 设置为大写的F，这样缩写方便调用

import torch.nn.functional as F

一、常用操作

操作名	介绍
nn.Conv2d	在输入图像上应用2维卷积
nn.MaxPool2d	在输入图像上应用2维最大池化
nn.AvgPool2d	在输入图像上应用2维平均池化
nn.ReLU	应用非线性修正单元ReLU
nn.Linear	对输入数据应用线性变换，也就是我们常说的全连接层
nn.CrossEntropyLoss	交叉熵损失函数
nn.Upsample	上采样，图像分割用的很多
nn.Dropout	应用Dropout层
nn.MSELoss	均方误差损失函数
nn.BatchNorm1d	应用BN层

因为方法太多，这里只是列举了一小部分，详细请自行去PyTorch官网查看。所列举的常用方法也只是以常用使用方式来进行举例（由于有些方法的参数实在是太多了，而且以我自己的能力也不一定能以书面文字的方式解释清楚）。

nn.Conv2d(in_channels,out_channels,kernel_size)：可选参数这里省略了
- in_channels(int)：输入图像的通道数
- out_channels(int)：卷积生成的通道数
- kernel_size(int or tuple)：卷积核的size，如果是方形，用int；如果非方形，用tuple。
- 案例
```
# With square kernels and equal stride
m = nn.Conv2d(16,33,3,stride = 2)
# With square kernels and unequal stride and with padding
m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
input = torch.randn(20,16,50,100)
output = m(input)
```
nn.MaxPool2d(kernel_size，stride)：这里列举了常用的几个参数，其余省略了
- kernel_size(int or tuple)：池化窗口size
- stride(int or tuple)：池化的步长
- padding(int or tuple)：池化的填充，默认为0
- 案例
```
# pool of square window of size=3, stride=2
m = nn.MaxPool2d(3,stride = 2)
# pool of non-square window
m = nn.MaxPool2d((3, 2), stride=(2, 1))
input = torch.randn(20, 16, 50, 32)
output = m(input)
```
nn.AvgPool2d(kernel_size，stride)：这里列举了常用的几个参数，其余省略了
- kernel_size(int or tuple)：池化窗口size
- stride(int or tuple)：池化的步长
- padding(int or tuple)：池化的填充，默认为0
- 案例
```
# pool of square window of size=3, stride=2
m = nn.AvgPool2d(3, stride=2)
# pool of non-square window
m = nn.AvgPool2d((3, 2), stride=(2, 1))
input = torch.randn(20, 16, 50, 32)
output = m(input)
```
nn.Linear(in_features, out_features, bias)
- in_features：输入特征数
- out_features：输出特征数
- bias：偏置
- 案例
```
m = nn.Linear(20, 30)
input = torch.randn(128, 20)
output = m(input)
print(output.size())
torch.Size([128, 30])
```

二、案例+相关代码注释

在这之前，首先我们需要了解一下PyTorch中已经给我们准备好的网络模型nn.Module。我们自己定义的网络模型只需要继承nn.Module，并实现它的forward()方法，PyTorch会根据Autograd，自动实现backward()函数，在forward函数中我们可以使用任何Tensor支持的函数，还可以使用if、for、print等Python语法，写法与标准Python写法是一致的。

class Net(nn.Module):def __init__(self):# nn.Module子类的函数必须在构造函数中执行父类的构造函数super(Net, self).__init__()# 卷积层 '1'表示输入图片为单通道， '6'表示输出通道数，'3'表示卷积核为3*3self.conv1 = nn.Conv2d(1, 6, 3) #线性层，输入1350个特征，输出10个特征self.fc1   = nn.Linear(1350, 10)  #这里的1350是如何计算的呢？这就要看后面的forward函数#正向传播 def forward(self, x): print(x.size()) # 结果：[1, 1, 32, 32]# 卷积 -> 激活 -> 池化 x = self.conv1(x) #根据卷积的尺寸计算公式，计算结果是30，具体计算公式后面第二章第四节 卷积神经网络 有详细介绍。x = F.relu(x)print(x.size()) # 结果：[1, 6, 30, 30]x = F.max_pool2d(x, (2, 2)) #我们使用池化层，计算结果是15x = F.relu(x)print(x.size()) # 结果：[1, 6, 15, 15]# reshape，‘-1’表示自适应#这里做的就是压扁的操作 就是把后面的[1, 6, 15, 15]压扁，变为 [1, 1350]x = x.view(x.size()[0], -1) print(x.size()) # 这里就是fc1层的的输入1350 x = self.fc1(x)        return xnet = Net()
print(net)

运行结果

Net((conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))(fc1): Linear(in_features=1350, out_features=10, bias=True)
)

网络的可学习参数通过net.parameters()返回

for parameters in net.parameters():print(parameters)

运行结果

Parameter containing:
tensor([[[[ 0.2745,  0.2594,  0.0171],[ 0.0429,  0.3013, -0.0208],[ 0.1459, -0.3223,  0.1797]]],[[[ 0.1847,  0.0227, -0.1919],[-0.0210, -0.1336, -0.2176],[-0.2164, -0.1244, -0.2428]]],[[[ 0.1042, -0.0055, -0.2171],[ 0.3306, -0.2808,  0.2058],[ 0.2492,  0.2971,  0.2277]]],[[[ 0.2134, -0.0644, -0.3044],[ 0.0040,  0.0828, -0.2093],[ 0.0204,  0.1065,  0.1168]]],[[[ 0.1651, -0.2244,  0.3072],[-0.2301,  0.2443, -0.2340],[ 0.0685,  0.1026,  0.1754]]],[[[ 0.1691, -0.0790,  0.2617],[ 0.1956,  0.1477,  0.0877],[ 0.0538, -0.3091,  0.2030]]]], requires_grad=True)
Parameter containing:
tensor([ 0.2355,  0.2949, -0.1283, -0.0848,  0.2027, -0.3331],requires_grad=True)
Parameter containing:
tensor([[ 2.0555e-02, -2.1445e-02, -1.7981e-02,  ..., -2.3864e-02,8.5149e-03, -6.2071e-04],[-1.1755e-02,  1.0010e-02,  2.1978e-02,  ...,  1.8433e-02,7.1362e-03, -4.0951e-03],[ 1.6187e-02,  2.1623e-02,  1.1840e-02,  ...,  5.7059e-03,-2.7165e-02,  1.3463e-03],...,[-3.2552e-03,  1.7277e-02, -1.4907e-02,  ...,  7.4232e-03,-2.7188e-02, -4.6431e-03],[-1.9786e-02, -3.7382e-03,  1.2259e-02,  ...,  3.2471e-03,-1.2375e-02, -1.6372e-02],[-8.2350e-03,  4.1301e-03, -1.9192e-03,  ..., -2.3119e-05,2.0167e-03,  1.9528e-02]], requires_grad=True)
Parameter containing:
tensor([ 0.0162, -0.0146, -0.0218,  0.0212, -0.0119, -0.0142, -0.0079,  0.0171,0.0205,  0.0164], requires_grad=True)

net.named_parameters可同时返回可学习的参数及名称。


for name,parameters in net.named_parameters():print(name,':',parameters.size())

我们来简单测试一下：注意forward函数的输入和输出都是Tensor


input = torch.randn(1, 1, 32, 32) # 这里的对应前面fforward的输入是32
out = net(input)
out.size()

在反向传播前，先要将所有参数的梯度清零

net.zero_grad()
out.backward(torch.ones(1,10)) # 反向传播的实现是PyTorch自动实现的，我们只要调用这个函数即可

注意： torch.nn只支持mini-batches，不支持一次只输入一个样本，即一次必须是一个batch。
也就是说，就算我们输入一个样本，也会对样本进行分批，所以，所有的输入都会增加一个维度，我们对比下刚才的input，nn中定义为3维，但是我们人工创建时多增加了一个维度，变为了4维，最前面的1即为batch-size。

三、优化器optim

在反向传播计算完所有参数的梯度后，还需要使用优化方法来更新网络的权重和参数。这里只简单介绍优化方法。

优化方法	优化更新策略
SGD随机梯度下降法

带有Momentum的随机梯度下降法

Adagrad

Adam	该方法融合了Momentum和Adagrad方法

在torch.optim库中实现大多数的优化方法，例如RMSProp、Adam、SGD等，下面我们使用SGD做个简单的样例。

首先导入optim包

import torch.optim

对网络参数进行更新

out = net(input) # 这里调用的时候会打印出我们在forword函数中打印的x的大小
criterion = nn.MSELoss()
loss = criterion(out, y)
#新建一个优化器，SGD只需要要调整的参数和学习率
optimizer = torch.optim.SGD(net.parameters(), lr = 0.01)
# 先梯度清零(与net.zero_grad()效果一样)
optimizer.zero_grad()
loss.backward()#更新参数
optimizer.step()

参考文献

https://pytorch.org/docs/stable/nn.html
https://github.com/zergtant/pytorch-handbook/blob/master/chapter2/2.1.3-pytorch-basics-nerual-network.ipynb