Pytorch 60 Minute Blitz Translation

2017-11-08

tensorflow太慢，caffe太垃圾，所以决定投入到pytorch的怀抱，入门资料直接看官网教程，http://pytorch.org/tutorials/。

什么是Pytorch

Pytorch 是一种基于Python的科学计算包，主要有两个主要目的：

替代numpy来发挥GPU在计算中的强大功能
作为一种深度学习研究平台，提高开发人员在开发深度学习代码的速度的同时，赋予其极大的代码自由度

Tensors基本单元

这就跟tensorflow有点像了，顾名思义，tensorflow的基本单元就是tensor, 也就是张量[4], 具体解释张量比较复杂，就暂时记住向量是一维张量，矩阵是二维张量，立方体方阵是三维张量就好。

下面举一个使用Pytorch创建一个二维张量即矩阵的例子：

1
2
3

torch # 引入pytorch, 必需操作
x = torch.Tensor(5, 3)
print(x)

此时会输出一个没有初始化的5x3矩阵：

0.0000e+00 0.0000e+00 2.1019e-44
0.0000e+00 0.0000e+00 0.0000e+00
6.1501e+19 1.3563e-19 0.0000e+00
0.0000e+00 2.1019e-44 0.0000e+00
0.0000e+00 0.0000e+00 1.2102e+25

其他tensor的基本操作如下：

y = torch.rand(5, 3)  #随机生成5x3矩阵
torch.add(x, y) #张量加法
result = torch.Tensor(5, 3)
torch.add(x, y, out=result) #方法中可以加入结果变量
y.add_(x) #另一种加法的形式
y[:,1] # 矩阵第几列
# 函数后面跟_的一般都会改变张量的值，如copy_ t_

numpy与pytorch数据结构的转换

x = torch.ones(5)  #创建一个一维张量，值都是1
y = x.numpy() # 一维张量转numpy的数组，此时y只是x的浅拷贝
x.add_(1) #此次操作后，y的值也会改变
z = torch.from_numpy(y)  #再转为一维张量，此时也只是浅拷贝

cuda数据

使用.cuda函数转换为cuda数据格式：

if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
    x + y

Autograd 自动求导包

自动求导包可以说是整个Pytorch的核心，看神经网络之前我们先来了解一下autograd这个包。
自动求导包Autograd定义了所有在tensor上的求导操作。这个包的各种规则的结果都是运行时确定，也就意味着你的反向传播算法的流程和结果是在你的代码运行的时候被确定的，每一次迭代的结果都有可能不同。

Variable类

autograd.Variable类是Autograd包的核心，当然了，只有变量才能求梯度，标量就没有梯度这个说法。这个类主要用来封装Tensor,并且几乎支持所有对Tensor的操作。每当结束对一个变量的运算的时候，调用.backward()函数，就可以自动计算出变量在运算过程中所发生的梯度变化。

Variable类的内部数据结构如下：
其中.data是tensor的数据值，.grad是运算过程中的梯度变化。Variable类还有一个比较特殊的内部成员是creator或者grad_fn,这个主要用来记录产生这个变量的函数，变量一般都是由函数的运算值，比如c=a+b, 此时对应的函数就是f(a,b) = a + b，函数与变量之间的相互组合和迭代构成了我们整个运算的过程（由用户自己创建的变量的grad_fn是None）。

如果你想要计算梯度的话，可以执行变量中的.backward()方法。如果变量是一个标量（单元素数据），那你就不用担心backward()函数的参数，如果有更多的元素的话，你需要指定一个和tensor的形状相匹配的grad_output参数。

x = Variable(torch.ones(2, 2), requires_grad=True)
print(x)
y = Variable(x.data + 2, requires_grad=True)
z = Variable(y.data * y.data * 3, requires_grad=True)  # z = 3 ( x + 2 )
out = z.mean() # out = 1/4 Σ 3 (xi + 2)^2
out.backward() # 此时由out对每个xi求导，即 out = 3/2 ( xi + 2)
# 当xi = 1 是 梯度为 4.5
print(x.grad)
#output:
#4.5000 4.5000
#4.5000 4.5000

上述情况out是一个标量，所以不需要指定求导类型，但如果要对矢量求导，需要指定求导梯度的形式：

x = torch.randn(3)
print(x)
x = Variable(x, requires_grad=True)
y = x * 2
while y.data.norm() < 1000:
    y = y * 2
print(y)
gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)
print(x.grad)

神经网络

神经网络可以使用torch.nn包来构建。
看完前文，应该对自动求导autograd包已经有了一定的了解，神经网络的模型构建和梯度下降的计算都依赖于Autograd包。nn.Module包含了各种层以及一个forward方法用于返回output值。

举一个数字图像识别神经网络的例子：
这是一个简单的前馈神经网络。这个网络的主要工作流程就是，接受输入，然后将输入传递给之后的各层，最后将结果输出。
一个典型的神经网络的工作流程如下：

定义一个具有学习参数或者权重的神经网络。
根据数据库的输入进行多次迭代。
将输入不断前馈至神经网络的各层。
计算损失（输出与正确结果之间的误差）
由损失计算出神经网络的各个参数的下降梯度并将之反馈
更新神经网络的权重，典型的更新规则如下：

定义神经网络

简单了解卷积神经网络[5][6]卷积，池化(降维)，relu激活[7]

import torch
from torch.autograd import Variable
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, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 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):
        # 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

GPU上训练

用把Tensor换成GPU的Tensor的方法，来将神经网络转换成为GPU上的神经网络。这个方法可以递归地将网络中所有的参数和缓冲转换为CUDA的tensor。

1	net.cuda()

记住也要将输入和标记也以GPU的形式传进去：

1	inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())

数据集太小的话感受不到GPU的加速效果哈，想体验就掏钱买GPU。
好的，并行自己看哈。

Reference

[1] http://pytorch.org/tutorials/
[2] https://www.zhihu.com/question/55720139
[3] https://zhuanlan.zhihu.com/p/25572330
[4] https://www.zhihu.com/question/20695804
[5] https://www.zhihu.com/question/39022858
[6] http://scs.ryerson.ca/
[7] http://m.blog.csdn.net/dajiabudongdao/article/details/77263608
[8] http://blog.csdn.net/zzw000000/article/details/77949570