使用pytorch构建神经网络的流程以及一些问题
使用PyTorch构建神经网络十分的简单，下面是我总结的PyTorch构建神经网络的一般过程以及我在学习当中遇到的一些问题，期望对你有所帮助。
PyTorch构建神经网络的一般过程
下面的程序是PyTorch官网60分钟教程上面构建神经网络的例子，版本0.4.1：
import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
# 第一步：准备数据
# Compose是将两个转换的过程组合起来，ToTensor将numpy等数据类型转换为Tensor，将值变为0到1之间
# Normalize用公式(input-mean)/std 将值进行变换。这里mean=0.5，std=0.5,是将[0,1]区间转换为[-1,1]区间
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# trainloader 是一个将数据集和采样策略结合起来的，并提供在数据集上面迭代的方法
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=0)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=0)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 第二步：构建神经网络框架，继承nn.Module类
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
# 第三步：进行训练
# 定义损失策略和优化方法
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# 训练神经网络
for epoch in range(4):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
optimizer.zero_grad()
# 训练过程1：前向过程，计算输入到输出的结果
outputs = net(inputs)
# 训练过程2：由结果和label计算损失
loss = criterion(outputs, labels)
# 训练过程3：在图的层次上面计算所有变量的梯度
# 每次计算梯度的时候，其实是有一个动态的图在里面的，求导数就是对图中的参数w进行求导的过程
# 每个参数计算的梯度值保存在w.grad.data上面，在参数更新时使用
loss.backward()
# 训练过程4：进行参数的更新
# optimizer不计算梯度，它利用已经计算好的梯度值对参数进行更新
optimizer.step()
running_loss += loss.item() # item 返回的是一个数字
if i % 2000 == 1999:
print('[%d, %5d] loss: %.3f' %
(epoch+1, i+1, running_loss/2000))
running_loss = 0.0
print('Finished Training')
# 第四步：在测试集上面进行测试
total = 0
correct = 0
with torch.no_grad():
for data in testloader:
images, label = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == label).sum().item()
print("Accuracy of networkd on the 10000 test images: %d %%" % (100*correct/total))
这个例子说明了构建神经网络的四个步骤：1：准备数据集 。2：构建神经网络框架，实现神经网络的类。 3：在训练集上进行训练。 4：在测试集上面进行测试。
而在第三步的训练阶段，也可以分为四个步骤：1：前向过程，计算输入到输出的结果。2：由结果和labels计算损失。3：后向过程，由损失计算各个变量的梯度。4：优化器根据梯度进行参数的更新。
训练过程中第loss和optim是怎么联系在一起的
loss是训练阶段的第三步，计算参数的梯度。optim是训练阶段的第四步，对参数进行更新。在optimizer初始化的时候，optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)，获取了参数的指针，可以对参数进行修改。当loss计算好参数的梯度以后，把值放在参数w.grad.data上面，然后optimizer直接利用这个值对参数进行更新。
以SGD为例，它进行step的时候的基本操作是这样的： p.data.add_(-group['lr'], d_p)，其中 d_p = p.grad.data
为什么要进行梯度清零
在backward每次计算梯度的时候，会将新的梯度值加到原来旧的梯度值上面，这叫做梯度累加。下面的程序可以说明什么是梯度累加：
import torch
x = torch.rand(2, requires_grad=True)
y = x.mean() # y = (x_1 + x_2) / 2 所以求梯度后应是0.5
y.backward()
print(x.grad.data) # 输出结果：tensor([0.5000, 0.5000])
y.backward()
print(x.grad.data) # 输出结果：tensor([1., 1.]) 说明进行了梯度累积
求解梯度过程和参数更新过程是分开的，这对于那些需要多次求导累计梯度，然后一次更新的神经网络可能是有帮助的，比如RNN，对于DNN和CNN不需要进行梯度累加，所以需要进行梯度清零。
如何使用GPU进行训练
旧版本：
use_cuda = True if torch.cuda.is_available() else False # 是否使用cuda
if use_cuda:
model = model.cuda() # 将模型的参数放入GPU
if use_cuda:
inputs, labels = inputs.cuda(), labels.cuda() # 将数据放入到GPU
0.4版本以后推荐新方法 to(device)，
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device) #将模型的参数放入GPU中
inputs, labels = inputs.to(device), labels.to(device) # 将数据放入到GPU中
参考：
Pytorch内部中optim和loss是如何交互的？ - 罗若天的回答 - 知乎
pytorch学习笔记（二）：gradient
