实战 | 手把手教你用PyTorch实现图像描述（附完整代码）

作者 | 李理

环信人工智能研发中心 VP，十多年自然语言处理和人工智能研发经验。主持研发过多款智能硬件的问答和对话系统，负责环信中文语义分析开放平台和环信智能机器人的设计与研发。

想要详细了解该系列文章，营长建议你先阅读上篇：一文详解循环神经网络的基本概念（代码版）

Tensor

和TensorFlow 类似，PyTorch 的核心对象也是Tensor。下面是创建Tensor 的代码：

x = torch.Tensor(5, 3)
print(x)

对应的下标是5，那么在这个下标的值为1，而其余的值为0，因此一个词只有一个位置不为0，所以叫作one-hot 的表示方法。这种表示方法的缺点是它是一种“稀疏”的表示方法，两个词，不论语义是相似还是不同，都无法通过这个向量表示出来。比如我们计算两个向量的内积，相同的词内积为1（表示相似度很高）；而不同的词为0（表示完全不同）。但实际我们希望“猫”和“狗”的相似度要高于“猫”和“石头”，使用one-hot 就无法表示出来。

Word Embedding 的思想是把高维的稀疏向量映射到一个低维的稠密向量，要求是两个相似的词会映射到低维空间里距离比较近的两个点；而不相似的距离较远。我们可以这样来“理解”这个低维的向量——假设语义可以用n 个基本的“正交”的“原子”语义表示的话，那么向量的不同的维代表这个词在这个原子语义上的“多少”。

当然这只是一种假设，但实际这个语义空间是否存在，或者即使存在也可能和人类理解的不同，但是只要能达到前面的要求——相似的词的距离近而不相似的远，也就可以了。

举例来说，假设向量的第一维表示动物，那么猫和狗应该在这个维度上有较大的值，而石头应该较小。

Embedding 一般有两种方式得到，一种是通过与任务无直接关系的无监督任务中学习，比如早期的RNN 语言模型，它的一个副产品就是Word Embedding，包括后来的专门Embedding 方法如Word to Vector 或者GloVe 等，本书后面的章节会详细介绍。另外一种方式就是在当前任务中让它自己学习出最合适的Word Embedding来。前一种方法的好处是可以利用海量的无监督数据，但是由于领域有差别以及它不是针对具体任务的最优化表示，它的效果可能不会很好；而后一种方法它针对当前任务学习出最优的表示（和模型的参数配合），但是它需要海量的训练数据，这对很多任务来说是无法满足的条件。在实践中，如果领域的数据非常少，我们可能直接用在其它任务中Pretraining 的Embedding 并且fix 住它；而如果领域数据较多的时候我们会用Pretraining 的Embedding 作为初始值，然后用领域数据驱动它进行微调。

PyTorch 基础知识

▌Tensor

和TensorFlow 类似，PyTorch 的核心对象也是Tensor。下面是创建Tensor 的代码：

x = torch.Tensor(5, 3)
print(x)

输出：

0.2455 0.1516 0.5319
0.9866 0.9918 0.0626
0.0172 0.6471 0.1756
0.8964 0.7312 0.9922
0.6264 0.0190 0.0041
[torch.FloatTensor of size 5x3]

我们可以得到Tensor 的大小：

print(x.size())
输出：
torch.Size([5, 3])

▌Operation

和TensorFlow 一样，有了Tensor 之后就可以用Operation 进行计算了。但是和TensorFlow 不同，TensorFlow 只是定义计算图但不会立即“执行”，而Pytorch 的Operation 是马上“执行”的。所以PyTorch 使用起来更加简单，当然PyTorch 也有计算图的执行引擎，但是它不对用户可见，它是“动态”编译的。

首先是加分操作：

y = torch.rand(5, 3)
print(x + y)

上面的加法会产生一个新的Tensor，但是我们可以提前申请一个Tensor 来存储Operation 的结果：

result = torch.Tensor(5, 3)
torch.add(x, y, out=result)
print(result)

也可以in-place 的修改：

# adds x to y
y.add_(x)
print(y)

一般来说，如果一个方法已_ 结尾，那么这个方法一般来说就是in-place 的函数。

PyTorch 支持numpy 的索引操作，比如取第一列：

print(x[:, 1])

我们也可以用view 来修改Tensor 的shape，注意view 要求新的Tensor 的元素个数和原来是一样的。

x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8) # the size -1 is inferred from other dimensions
print(x.size(), y.size(), z.size())
输出：torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])

▌numpy ndarray 的转换

我们可以很方便的把Tensor 转换成numpy 的ndarray 或者转换回来，注意它们是共享内存的，修改Tensor 会影响numpy 的ndarray，反之亦然。

Tensor 转numpy

a = torch.ones(5)
b = a.numpy()
a.add_(1) # 修改a会影响b

numpy 转Tensor

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a) # 修改a会影响b

▌CUDA Tensor

Tensor 可以移到GPU 上用GPU 来加速计算：

# let us run this cell only if CUDA is available
if torch.cuda.is_available():
x = x.cuda()
y = y.cuda()
x + y 在GPU上计算

图5.18: PyTorch 的变量

▌Autograd

autograd 是PyTorch 核心的包，用于实现前面我们提到的自动梯度算法。首先我们介绍其中的变量。

▌Variable

autograd.Variable 是Tensor 的封装，我们定义（也就计算）好了最终的变量(一般是Loss) 后，我们可以调用它的backward() 方法，PyTorch 就会自动的计算好梯度。如图5.18所示，PyTorch 的变量值会存储到data 里，而梯度值会存放到grad 里，此外还有一个grad_fn，它是用来计算梯度的函数。除了用户创建的Tensor 之外，通过Operatioon 创建的变量会记住它依赖的变量，从而形成一个有向无环图。计算这个变量的梯度的时候会自动计算它依赖的变量的梯度。

我们可以这样定义变量，参数requires_grad 说明这个变量是否参与计算梯度：

x = Variable(torch.ones(2, 2), requires_grad=True)

▌Gradient

我们可以用backward() 来计算梯度，它等价于variable.backward(torch.Tensor([1.0]))，梯度会往后往前传递，最后的变量一般传递的就是1，然后往前计算梯度的时候会把之前的值累积起来，PyTorch 会自动处理这些东西，我们不需要考虑。

x = Variable(torch.ones(2, 2), requires_grad=True)
y=x+2
z = y * y * 3
out = z.mean()
out.backward() # 计算所有的dout/dz,dout/dy,dout/dx
print(x.grad) # x.grad就是dout/dx
输出为：
4.5000 4.5000
4.5000 4.5000
[torch.FloatTensor of size 2x2]

我们手动来验证一下：

注意每次调用backward() 都会计算梯度然后累加到原来的值之上，所以如果每次计算梯度之前要调用变量的zero_grad() 函数。

▌变量的requires_grad 和volatile

每个变量有两个flag：requires_grad 和volatile，它们可以细粒度的控制一个计算图的某个子图不需要计算梯度，从而可以提高计算速度。一个Operation 如果所有的输入都不需要计算梯度(requires_grad==False)，那么这个Operation 的requires_grad就是False，而只要有一个输入，那么这个Operation 就需要计算梯度。比如下面的代码片段：

>>> x = Variable(torch.randn(5, 5))
>>> y = Variable(torch.randn(5, 5))
>>> z = Variable(torch.randn(5, 5), requires_grad=True)
>>> a = x + y
>>> a.requires_grad
False
>>> b = a + z
>>> b.requires_grad
True

如果你想固定住模型的某些参数，或者你知道某些参数的梯度不会被用到，那么就可以把它们的requires_grad 设置成False。比如我们想细调(fine-tuing) 预先训练好的一个CNN，我们会固定所有最后全连接层之前的卷积池化层参数，我们可以这样：

model = torchvision.models.resnet18(pretrained=True)
for param in model.parameters():
  param.requires_grad = False
 
# 把最后一个全连接层替换成新构造的全连接层
# 默认的情况下，新构造的模块的requires_grad=True
model.fc = nn.Linear(512, 100)

# 优化器只调整新构造的全连接层的参数。
optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)

volatile 在0.4.0 之后的版本以及deprecated 了，不过我们后面的代码会用到它之前的版本，因此还是需要了解一下。它适用于预测的场景，在这里完全不需要调用backward() 函数。它比requires_grad 更加高效，而且如果volatile 是True，那么它会强制requires_grad 也是True。它和requires_grad 的区别在于：如果一个Operation的所有输入的requires_grad 都是False 的时候，这个Operation 的requires_grad 才是False，这时这个Operation 就不参与梯度的计算；而如果一个Operation 的一个输入是volatile 是True，那么这个Operation 的volatile 就是True 了，那么这个Operation 就不参与梯度的计算了。因此它很适合的预测场景时：不修改模型的任何定义，只是把输入变量（的一个）设置成volatile，那么计算forward 的时候就不会保留任何用于backward 的中间结果，这样就会极大的提高预测的速度。下面是示例代码：

>>> regular_input = Variable(torch.randn(1, 3, 227, 227))
>>> volatile_input = Variable(torch.randn(1, 3, 227, 227), volatile=True)
>>> model = torchvision.models.resnet18(pretrained=True)
>>> model(regular_input).requires_grad
True
>>> model(volatile_input).requires_grad
False
>>> model(volatile_input).volatile
True
>>> model(volatile_input).grad_fn is None
True

图5.19: 卷积网络

▌神经网络

有了前面的变量和梯度计算，理论上我们就可以自己实现各种深度学习算法，但用户会有很多重复的代码，因此PyTorch 提供了神经网络模块torch.nn。在实际的PyTorch 开发中，我们通过继承nn.Module 来定义一个网络，我们一般值需要实现forward() 函数，而PyTorch 自动帮我们计算backward 的梯度，此外它还提供了常见的Optimizer 和Loss，减少我们的重复劳动。我们下面会实现如图5.19的卷积网络，因为之前已经详细的介绍了理论的部分，我们这里只是简单的介绍怎么用PyTorch 来实现。

完整代码：

https://github.com/fancyerii/deep_learning_theory_and_practice/

blob/master/codes/ch05/PyTorch%20CNN.ipynb

对于PyTorch 的开发来说，一般是如下流程：

• 定义网络可训练的参数

• 变量训练数据

• forward 计算loss

• backward 计算梯度

• 更新参数，比如weight = weight - learning_rate * gradient

下面我们按照前面的流程来实现这个卷积网络。

定义网络

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module): # 必须集成nn.Module
   def __init__(self):
      super(Net, self).__init__() # 必须调用父类的构造函数，传入类名和self
      # 输入是1个通道(灰度图)，卷积feature
          map的个数是6，大小是5x5，无padding，stride是1。
      self.conv1 = nn.Conv2d(1, 6, 5)
      # 第二个卷积层feature map个数是16，大小还是5*5，无padding，stride是1。
self.conv2 = nn.Conv2d(6, 16, 5)
      # 仿射层y = Wx + b，ReLu层没有参数，因此不在这里定义
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
   # 卷积然后Relu然后2x2的max pooling
   x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
   # 再一层卷积relu和max pooling
   x = F.max_pool2d(F.relu(self.conv2(x)), 2)
   # 把batch x channel x width x height 展开成batch x all_nodes
   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:] # 除了batchSize之外的其它维度
   num_features = 1
   for s in size:
       num_features *= s
    return num_features

net = Net()

print(net)

输出为：

Net(
 (conv1): Conv2d (1, 6, kernel_size=(5, 5), stride=(1, 1))
 (conv2): Conv2d (6, 16, kernel_size=(5, 5), stride=(1, 1))
 (fc1): Linear(in_features=400, out_features=120)
 (fc2): Linear(in_features=120, out_features=84)
 (fc3): Linear(in_features=84, out_features=10)
)

我们值需要实现forward() 函数，PyTorch 会自动帮我们实现backward() 和梯度计算。我们可以列举net 的所有可以训练的参数，前面我们在Net 里定义的所有变量都会保存在net 的parameters 里。

params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight
10
torch.Size([6, 3, 5, 5])

代码要求forward 的输入是一个变量(不需要梯度)，它的大小是batch x 1 x 32 x 32。

input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)

注意，我们直接调用net(input)，不需要显式调用forward() 方法。我们可以调用backward() 来计算梯度，调用前记得调用zero_grad。

net.zero_grad()
out.backward(torch.randn(1, 10))

nn.Conv2d() 只支持batch 的输入，如果只有一个数据，也要转成batchSize 为1 的输入。如果输入是channel x width x height，我们可以使用input.unsqueeze(0) 把它变成1 x channel x width x height 的。

损失函数

接下来我们会定义损失函数，PyTorch 为我们提供了很多常见的损失函数，比如

MSELoss：

output = net(input)
target = Variable(torch.arange(1, 11)) # 只是示例
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)

如果我们沿着loss 从后往前用grad_fn 函数查看，可以得到如下：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss

我们可以用next_function 来查看之前的grad_fn。

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

梯度计算

有了Loss 之后我们就可以计算梯度：

net.zero_grad() # 记得清零。
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

更新参数

我们可以自己更新参数：weight = weight - learning_rate * gradient。比如代码：

learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)

但是除了标准的SGD 算法，我们前面还介绍了很多算法比如Adam 等，没有必要让大家自己实现，所以PyTorch 提供了常见的算法，包括SGD：

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() # 更新参数

数据集和transforms

对于常见的MNIST 和CIFAR-10 数据集，PyTorch 自动提供了下载和读取的代码：

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)

这里有个transform，datasets.CIFAR10 返回的是PIL 的[0,1] 的RGB 值，我们首先转成Tensor，然后在把它转换成[-1,1] 区间的值。transforms.Normalize(0.5,0.5) 会用如下公式进行归一化：

input[channel] = (input[channel] − mean[channel])/std[channel]

对于上面的取值input=(input-0.5)*2，也就是把范围从[0,1] 变成[-1,1]。关于Dataset和DataLoader 更多细节，请参考完整代码。

完整代码在ch05/PyTorch CNN.ipynb。我们这里的目的只是介绍PyTorch 的基本概念，因此使用了最简单的CNN。

PyTorch 循环网络示例

接下来我们通过几个示例介绍怎么在 PyTorch 里使用卷积网络。

▌姓名分类

这个示例会构建一个分类器，输入是一个姓名，输出是这个姓名的人可能来自哪个国家。我们下面会训练一个字符级别的RNN 模型来预测一个姓名是哪个国家人的姓名。我们的数据集收集了18 个国家的近千个人名(英文名，注意中国人也是英文名，否则就是语言识别问题了），我们最终的模型就可以预测这个姓名是哪个国家的人。

完整代码在

https://github.com/fancyerii/deep_learning_theory_and_practice/blob/

master/codes/ch05/Char%20RNN%20Classifier.ipynb

数据准备

在data/names 目录下有18 个文本文件，命名规范为[语言].txt。每个文件的每一行都是一个人名。此外，我们实现了一个unicode_to_ascii 把诸如à 之类转换成a。最终我们得到一个字典category_lines，language: [names ...]。key 是语言名，value 是名字的列表。all_letters 里保存所有的字符。

import glob

all_filenames = glob.glob('../data/names/*.txt')
print(all_filenames)

import unicodedata
import string

all_letters = string.ascii_letters + " .,;'"
n_letters = len(all_letters)

# http://stackoverflow.com/a/518232/2809427
def unicode_to_ascii(s):
  return ''.join(
      c for c in unicodedata.normalize('NFD', s)
      if unicodedata.category(c) != 'Mn'
      and c in all_letters
)

print(unicode_to_ascii('Ślusàrski'))

category_lines = {}
all_categories = []

def readLines(filename):
  lines = open(filename).read().strip().split('\n')
  return [unicode_to_ascii(line) for line in lines]

for filename in all_filenames:
  category = filename.split('/')[-1].split('.')[0]
  all_categories.append(category)
  lines = readLines(filename)
  category_lines[category] = lines
 
n_categories = len(all_categories)
print('n_categories =', n_categories)

把姓名(String) 变成Tensor

现在我们已经把数据处理好了，接下来需要把姓名从字符串变成Tensor，因为机器学习只能处理数字。为了表示一个字母，我们使用“one-hot” 的表示方法。这是一个长度为<1 x n_letters> 的向量，对应字符的下标为1，其余为0。对于一个姓名，我们用大小为 的Tensor 来表示。第二维表示batch 大小，因为PyTorch 的RNN 要求输入是< time x batch x input_features>。

import torch

# 把一个字母变成<1 x n_letters> Tensor
def letter_to_tensor(letter):
   tensor = torch.zeros(1, n_letters)
   letter_index = all_letters.find(letter)
   tensor[0][letter_index] = 1
   return tensor

# 把一行(名字)转换成的Tensor
def line_to_tensor(line):
   tensor = torch.zeros(len(line), 1, n_letters)
   for li, letter in enumerate(line):
       letter_index = all_letters.find(letter)
       tensor[li][0][letter_index] = 1
return tensor

创建网络

如果想“手动”创建网络，那么在PyTorch 里创建RNN 和全连接网络的代码并没有太大差别。因为PyTorch 的计算图是动态实时编译的，不同time-step 的for 循环不需要“内嵌”在RNN 里。因此每个训练数据即使长度不同也没有关系，因为每次都是根据当前的数据长度“实时”编译出来的计算图。网络结构如下图所示：

图5.20: RNN 分类器网络结构

这个网络结构和vanilla RNN 的区别在于我们使用了两个全连接层，一个用于计算新的hidden；另一个用于计算当前的输出。而在vanilla RNN 中只有一个全连接层计算hidden，同时用这个hidden 计算输出。定义网络的代码如下：

import torch.nn as nn
from torch.autograd import Variable

class RNN(nn.Module):
   def __init__(self, input_size, hidden_size, output_size):
       super(RNN, self).__init__()

self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size

self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim=1)

def forward(self, input, hidden):
  combined = torch.cat((input, hidden), 1)
  hidden = self.i2h(combined)
  output = self.i2o(combined)
  output = self.softmax(output)
  return output, hidden
def init_hidden(self):
  return Variable(torch.zeros(1, self.hidden_size))

和之前的全连接网络一样， 首先我们的类需要基础nn.Module 并且实现

__init__、forward 和init_hidden 这3 个方法。在__init__ 方法里，我们定

义网络中的变量，以及两个全连接层。forward 函数根据当前的输入input 和上一个时刻的hidden 计算新的输出和hidden。init_hidden 创建一个初始为0 的隐状态。

测试网络

定义好了网络之后我们可以测试一下：

n_hidden = 128
rnn = RNN(n_letters, n_hidden, n_categories)

input = Variable(line_to_tensor('Albert'))
hidden = Variable(torch.zeros(1, n_hidden))

# 实际是遍历所有input
output, next_hidden = rnn(input[0], hidden)
print(output)
hidden=net_hidden

准备训练

测试没什么问题之后就可以开始训练了。训练之前，我们需要一些工具函数。第一个就是根据网络的输出把它变成分类，我们这里使用Tensor.topk 来选取概率最大的那个下标，然后得到分类名称。

def category_from_output(output):
  top_n, top_i = output.data.topk(1) # Tensor out of Variable with .data
  category_i = top_i[0][0]
  return all_categories[category_i], category_i
 
print(category_from_output(output))

我们也需要一个函数来随机挑选一个训练数据：

import random

def random_training_pair():
  category = random.choice(all_categories)
  line = random.choice(category_lines[category])
  category_tensor =
      Variable(torch.LongTensor([all_categories.index(category)]))
  line_tensor = Variable(line_to_tensor(line))
  return category, line, category_tensor, line_tensor

for i in range(10):
  category, line, category_tensor, line_tensor = random_training_pair()
  print('category =', category, '/ line =', line)

训练

现在我们可以训练网络了，因为RNN 的输出已经取过log 了，所以计算交叉熵只需要选择正确的分类对于的值就可以了，PyTorch 提供了nn.NLLLoss() 函数来实现这个目的，它基本就是实现了loss(x, class) = -x[class]。

criterion = nn.NLLLoss()

我们可以用optimizer 而不是自己手动来更新参数，这里我们使用最原始的SGD 算法。

learning_rate = 0.005
optimizer = torch.optim.SGD(rnn.parameters(), lr=learning_rate)

训练的每个循环如下：创建输入和输出Tensor 创建初始化为零的隐状态Tensor for each letter in 输入Tensor: output, hidden=rnn(input,hidden) 计算loss backward 计算梯度optimizer.step

def train(category_tensor, line_tensor):
  rnn.zero_grad()
  hidden = rnn.init_hidden()

for i in range(line_tensor.size()[0]):
  output, hidden = rnn(line_tensor[i], hidden)

loss = criterion(output, category_tensor)
loss.backward()

optimizer.step()
return output, loss.data[0]

接下来我们就要用训练数据来训练了。因为上面的函数同时返回输出和损失，我们可以保存下来用于绘图。

import time
import math

n_epochs = 100000
print_every = 5000
plot_every = 1000

current_loss = 0
all_losses = []

def time_since(since):
  now = time.time()
  s = now - since
  m = math.floor(s / 60)
  s -= m * 60
  return '%dm %ds' % (m, s)

start = time.time()

for epoch in range(1, n_epochs + 1):
  # 随机选择一个样本
  category, line, category_tensor, line_tensor = random_training_pair()
  output, loss = train(category_tensor, line_tensor)
  current_loss += loss
 
  if epoch % print_every == 0:
    guess, guess_i = category_from_output(output)
    correct = '