PyTorch Tutorials 摘要(1) Deep Learning with PyTorch: A 60 minute blitz

---

0. 前言

• 官网链接
• 本文目标：
  • 总体了解PyTorch的Tensor以及神经网络相关内容。
  • 训练一个简单的图像分类网络。
• 主要内容（对我来说的要点）：
  • What is PyTorch：PyTorch的基本功能以及Tensor相关的基本操作。
    • in place操作，如x.add_(y)
  • Autograd: Automatic differentiation：自动微分相关API。
    • PyTorch中不推荐使用inplace操作，可能会导致自动求导时出错。
  • Neural Networks：简单介绍使用PyTorch构建神经网络的过程。
  • Training a classifier：自定义神经网络结构，训练cifar10。

---

1. What is PyTorch

• 本节链接
• PyTorch 是什么？
  • numpy 的GPU版实现。
  • 深度学习研究平台
• 介绍了PyTorch中tensor的几种新建方式：
  • torch.empty(5, 3)
  • torch.rand(5, 3)
  • torch.zeros(5, 3, dtype=torch.long)
  • torch.tensor([5.5, 3])
  • x.new_ones(5, 3, dtype=torch.double)
  • torch.randn_like(x, dtype=torch.float)
• Tensor相关的基本操作：
  • x.size()：获取tensor尺寸，返回值是 torch.Size 对象。
    • 如 torch.Size([5, 3])。
    • 是指是一个元组tuple，支持所有元组相关操作。
  • 向量加法：
    • x + y
    • z = torch.add(x, y)
    • torch.add(x, y, result)
    • y.add_(x)：in place 操作，即 y += x
  • reshape操作：x.view(-1, 8)
  • 如果tensor只有一个元素（不管是不是标量），都可以通过 x.item() 来获取Python类型的结果。
    • 有什么用？可用于获取loss，不用考虑CPU/GPU。
• tensor与numpy的相互转换
  • tonsor -> numpy: x.numpy()
  • numpy -> tensor: torch.from_numpy(ndarray)
• CUDA tensors
  • 准备工作：device = torch.device("cuda")
  • 直接定义CUDA tensor（指定device参数）：torch.ones_like(x, device=device)
  • CPU Tensor转换为CUDA tensor：cpu_tensor.to(device)
  • CUDA Tensor转换为CPU Tensor：cuda_tensor.to("cpu", torch.double)

---

2. Autograd: Automatic differentiation

• 本节链接，本节翻译
• 扩展阅读：
  • 浅谈 PyTorch 中的 tensor 及使用
  • PyTorch 的 Autograd
• 背景：神经网络的基础就是BP算法，而在各类深度学习框架中，一个基本实现BP的基本方法就是 Autograd（即自动求导）。
• 本章主要内容就是介绍了PyTorch中自动求导的应用。
• torch.Tensor是实现自动微分的核心。
• 如果在定义某tensor的时候设置 .requires_grad=True，则调用相关tensor的 .backward() 方法时就会计算之前tensor对应的提取，获取提取的方法是通过属性 .grad。
• 如果想要令某个tensor不再参与BP，则可以调用 .detach()。
• 如果想要令某些tensor不再参与BP，可以使用 with torch.no_grad(): 定义网络。
• 自动求导中很重要的一个类就是 Function，每个tensor都有一个 .grad_fn 属性，本质就是 Function的实例。
  • 手动实现的tensor的.grad_fn为None，自动生成的tensor都有设置该参数。
  • Function 指的是在计算图中某个节点（node）所进行的运算，比如加减乘除卷积等等之类的，Function 内部有 forward() 和 backward() 两个方法，分别应用于正向、反向传播。
• 调用 .backward() 方法时需要注意，如果tensor是一个标量（或者不是标量，但只有一个元素）则不需要输入任何参数，如果不是标量就需要输入一个张量，要求shape与该tensor相同。

---

3. Neural Networks

• 本节链接
• PyTorch中构建神经网络：
  • 一般基于 torch.nn 类。
  • 所有的模型（以及各种layer）都继承了 nn.Module，这个类中包含了前向过程forward(input)。
• 典型的卷积神经网络训练过程：
  • 定义一个神经网络，包括了一些需要训练的参数。
  • 遍历某个Dataset获取训练输入数据。
  • 通过正向传到得到模型输出结果。
  • 计算损失函数。
  • 通过自动微分求导。
  • 更新网络模型中的参数。
• 一个实例

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

# 定义一个模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 3x3 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        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:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

# 定义了模型还能输出查看
net = Net()
print(net)

# 获取模型参数
params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

# 模型前向传递，获得模型结果
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

# 清零梯度，并计算梯度
net.zero_grad()
out.backward(torch.randn(1, 10))

# 计算损失函数
output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)

# 手动更新梯度
learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

# 优化器自动更新梯度
import torch.optim as optim

# create your 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

---

4. Training a classifier

• 本节连接
• 使用了torchvision来实现CNN训练CIFAR10。

import torch
import torchvision
import torchvision.transforms as transforms

# 定义数据预处理方式
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

# 构建数据集
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=2)
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=2)

# 类别信息基本情况
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# 查看输入数据
import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

# 定义神经网络
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(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()

# 定义损失函数
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练模型
for epoch in range(2):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0
print('Finished Training')

# 保存模型
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)

# 测试模型
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

# 导入模型
net = Net()
net.load_state_dict(torch.load(PATH))

# 获取少量图片的预测结果
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))

# 在整个验证集上验证模型结果
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

# 查看每一类的预测结果
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1
for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

# GPU上训练
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)
inputs, labels = data[0].to(device), data[1].to(device)