神经网络可以通过torch.nn工具包创建，在前面我们已经简单介绍了autograd，nn依靠autograd定义模型并实现微分。一个nn.Module包含layers和一个forward(input)方法。
神经网络一个常见的训练过程如下：
（1）定义含有可训练参数的神经网络；
（2）遍历输入数据集；
（3）输入数据经过网络进行的相关运算（正向传播）；
（4）计算损失函数（loss）；
（5）梯度反向传播；
（6）更新网络权重，最简单的一个更新方法：
weight = weight - learning_rate * gradient
Define network
首先定义一个简单的神经网络：
import torch
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, 3) # input channel:1; output channel:6; kernel size：3*3
self.conv2 = nn.Conv2d(6, 16, 3) # input channel:6; output channel:16; kernel size：3*3
self.fc1 = nn.Linear(16 * 6 * 6, 120) # full connect
self.fc2 = nn.Linear(120, 84) # full connect
self.fc3 = nn.Linear(84, 10) # full connect
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
x = F.max_pool2d(F.relu(self.conv2(x)), (2, 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(
(conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))
(fc1): Linear(in_features=576, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
上面的网络结构示意图：
模型可训练参数可以通过net.parameters()查看：
params = list(net.parameters())
for i in range(len(params)):
print(params[i].size()) # weight & bias
输出结果：
torch.Size([6, 1, 3, 3]) #conv1 weight
torch.Size([6]) #conv1 bias
torch.Size([16, 6, 3, 3])
torch.Size([16])
torch.Size([120, 576])
torch.Size([120])
torch.Size([84, 120])
torch.Size([84])
torch.Size([10, 84])
torch.Size([10])
现在向网络中输入一个随机的样本：
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
输出结果：
tensor([[ 0.0688, -0.0847, 0.0974, -0.1122, 0.0627, 0.0300, -0.0888, -0.0528,
0.0811, 0.0312]], grad_fn=)
torch.nn只支持mini-batches，比如nn.Conv2d输入的是4D Tensor (nSamples * nchannels * height * width)，如果只有一个输入样本，可以使用input.unsqueeze(0)添加一个batch维度。
Loss Function
损失函数将(output, target)作为输入，计算结果用来估计output到target的距离。在nn包中有多种不同的损失函数，一个简单的损失函数是nn.MSELoss，用来计算output和target之间的均方差。
举一个例子：
target = torch.randn(10) # random create target
target = target.view(1, -1) # reshape target
criterion = nn.MSELoss()
loss = criterion(out, target)
print(loss)
得到结果：
tensor(1.5616, grad_fn=)
当我们调用loss.backward()，整个图会求loss的偏导，图中所有设置requires_grad=True的tensor，它们的.grad tensor都会累积梯度。
Backprop
为了反向传播误差，我们需要调用loss.backward()。我们需要清理已经存在的梯度，不然的话梯度会累积到之前的值上。
现在我们调用loss.backward()，并查看conv1的bias梯度在反向传播前后的变化：
net.zero_grad()
print(net.conv1.bias.grad) # before backward
loss.backward()
print(net.conv1.bias.grad) # after backward
输出结果：
None
tensor([-0.0133, 0.0076, 0.0047, -0.0117, -0.0077, 0.0037])
这里的输出结果很奇怪，官网给出的结果是中在backward之前的梯度是0，而我输出的结果是None，不知道问题出在哪里。
Update weights
最后就剩下更新权重了，最简单的一个方法就是随机梯度下降(Stochastic Gradient Descent, SGD):
weight = weight - learning_rate * gradient
一个简单的python实现：
learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)
除了上面介绍的SGD，还有Nesterov-SGD, Adam, RMSProp等等，Pytorch为了方便用户使用，提供了torch.optim包，里面有大部分常用的优化方法。
使用torch.optim的方法如下：
import torch.optim as optim
# create optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)
# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update
结语
本节代码可以从github上下载，github上提供了cpp和python两个版本的入门程序，仅供大家参考。