日期：2020.10.30
主题：PyTorch入门
内容：
具体代码如下 ↓
from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
"""
{神经网络}
通过torch.nn包来构建神经网络
它依赖于autograd包来定义模型并对它们求导。
一个nn.Module包含各个层和一个forward(input)方法，该方法返回output。
"""
"""
一个神经网络的典型训练过程如下：
1.定义包含一些可学习参数(或者叫权重）的神经网络；
2.在输入数据集上迭代；
3.通过网络处理输入；
4.计算loss(输出和正确答案的距离）；
5.将梯度反向传播给网络的参数；
6.更新网络的权重，一般使用一个简单的规则：
weight = weight - learning_rate * gradient
"""
"""
【定义网络】
"""
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 输入图像channel：1；输出channel：6；5x5卷积核
self.conv1 = nn.Conv2d(1, 6, 5) # 定义二维卷积 1 -> 6
self.conv2 = nn.Conv2d(6, 16, 5) # 定义二维卷积 6 -> 16
# an affine operation: 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):
# 2x2 Max pooling 池化操作
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
# 只需要定义forward函数，backward函数会在使用autograd时自动定义，backward函数用来计算导数。
# 可以在 forward 函数中使用任何针对张量的操作和计算
net = Net()
print(net)
print('-'*40, '\n')
"""
二维卷积
torch.nn.Conv2d(in_channels: int, out_channels: int,
kernel_size: Union[T, Tuple[T, T]])
*channel
即通道，最初是指电子图片中RGB通道这样的配色方案，
例如一张RGB图片可以用一个64x64x3的张量来表示，其中，channel=3，
分别为红色(Red)、绿色(Green)、蓝色(Blue)三个通道。
进一步，对RGB图片进行卷积操作后，根据过滤器的数量可产生更多的通道——特征图。
故，一个通道是对某个特征的检测，通道中某一处数值的强弱就是对当前特征强弱的反应。
in_channels
输入的四维张量[N, C, H, W]中的C，即输入张量的channels数。
这个形参是确定权重等可学习参数的shape所必需的。
out_channels
即期望的四维输出张量的channels数。
这里卷积层的权重和偏置初始化都是采用He初始化的，适合于ReLU函数。
*kernel
即核函数K（kernel function），指K(x, y) = <f(x), f(y)>，
其中x和y是n维的输入值，f() 是从n维到m维的映射（通常而言，m>>n）。
<x, y>是x和y的内积（inner product），亦称点积（dot product）
它有助于省去在高维空间里进行繁琐计算的“简便运算法”。
甚至，它能解决无限维空间无法计算的问题！
（因为有时f()会把n维空间映射到无限维空间）
kernel_size
即卷积核的大小，一层卷积核的中心pixel可以“看到”输入图 a*b 的区域（连通性）
一般使用5x5、3x3这种左右两个数相同的卷积核，
因此这种情况只需要写kernel_size = 5即可。
若左右两个数不同，比如3x5的卷积核，
则写作kernel_size = (3, 5)，
注意需要写一个tuple，而不能写一个列表（list）。
"""
"""
线性变换(连同偏置)，即 y = x * (W)^T + b
torch.nn.Linear(in_features: int, out_features: int)
in_features
输入张量的大小
out_features
输出张量的大小
"""
# 通过net.parameters()返回模型的可学习参数
params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight
print('-'*40, '\n')
# 尝试一个随机的32x32的输入（该网络(LeNet）的期待输入是32x32的张量）。
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
print('-'*40, '\n')
#清零所有参数的梯度缓存，然后进行随机梯度的反向传播
net.zero_grad()
out.backward(torch.randn(1, 10))
"""
torch.nn只支持小批量处理(mini-batches）。整个torch.nn包只支持小批量样本的输入，不支持单个样本的输入。
比如，nn.Conv2d 接受一个4维的张量，即nSamples x nChannels x Height x Width
如果是一个单独的样本，只需要使用input.unsqueeze(0)来添加一个“假的”批大小维度。
"""
"""
<回顾>
torch.Tensor
一个多维数组，支持诸如backward()等的自动求导操作，同时也保存了张量的梯度。
nn.Module
神经网络模块。是一种方便封装参数的方式，具有将参数移动到GPU、导出、加载等功能。
nn.Parameter
张量的一种，当它作为一个属性分配给一个Module时，它会被自动注册为一个参数。
autograd.Function
实现了自动求导前向和反向传播的定义，
每个Tensor至少创建一个Function节点，该节点连接到创建Tensor的函数并对其历史进行编码。
"""
"""
【损失函数】
函数接受一对(output, target)作为输入，计算一个值来估计网络的输出和目标值相差多少。
"""
# nn.MSELoss是比较简单的一种损失函数，计算输出和目标的均方误差(mean-squared error）。
output = net(input)
target = torch.randn(10) # 本例子中使用模拟数据
target = target.view(1, -1) # 使目标值与数据值尺寸一致
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)
print('-'*40, '\n')
"""
如果使用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属性累积着梯度张量。
"""
# 为了说明这一点，让我们向后跟踪几步
print(loss.grad_fn) # MSELoss
print(loss.grad_fn.next_functions[0][0]) # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU
print('-'*40, '\n')
"""
【反向传播】
我们只需要调用loss.backward()来反向传播误差。
我们需要清零现有的梯度，否则梯度将会与已有的梯度累加。
"""
# 调用loss.backward()，并查看conv1层的偏置(bias）在反向传播前后的梯度。
net.zero_grad() # 清零所有参数(parameter）的梯度缓存
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)
print('-'*40, '\n')
"""
【更新权重】
最简单的更新规则是随机梯度下降法(SGD）:
weight = weight - learning_rate * gradient
"""
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）
optimizer = optim.SGD(net.parameters(), lr=0.01)
# 在训练的迭代中：
optimizer.zero_grad() # 清零梯度缓存
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # 更新参数
