Pytorch基本概念

Pytorch 学习记录

什么是Pytorch

PyTorch是一个基于python的科学计算包，主要针对两类人群：

1.作为NumPy的替代品，可以利用GPU的性能进行计算
2.作为一个高灵活性、速度快的深度学习平台
PyTorch 是Torch7 团队开发的，从它的名字就可以看出，其与Torch 的不同之处在于PyTorch 使用了Python 作为开发语言。所谓“Python first”，同样说明它是一个以Python 优先的深度学习框架，不仅能够实现强大的GPU 加速，同时还支持动态神经网络，这是现在很多主流框架比如Tensorflow 等都不支持的。

PyTorch 既可以看做加入了GPU 支持的numpy，同时也可以看成一个拥有自动求导功能的强大的深度神经网络，除了Facebook 之外，它还已经被Twitter、CMU 和Salesforce 等机构采用。

为什么选择Pytroch？

面对如此多的深度学习框架，我们为何要选择PyTorch 呢？Tensorflow 不是深度学习框架默认的老大吗，为什么不直接选择Tensorflow 而是要选择PyTorch 呢？下面分4个方面来介绍为何要使用PyTorch。

（1）掌握一个框架并不能一劳永逸，现在深度学习并没有谁拥有绝对的垄断地位，就算是Google 也没有，所以只学习Tensorflow 并不够。同时现在的研究者使用各个框架的都有，如果你要去看他们实现的代码，至少也需要了解他们使用的框架，所以多学一个框架，以备不时之需。

（2）Tensorflow 与Caffe 都是命令式的编程语言，而且是静态的，首先必须构建一个神经网络，然后一次又一次使用同样的结构，如果想要改变网络的结构，就必须从头开始。但是对于PyTorch，通过一种反向自动求导的技术，可以让你零延迟地任意改变神经网络的行为，尽管这项技术不是PyTorch 独有，但目前为止它实现是最快的，能够为你任何疯狂想法的实现获得最高的速度和最佳的灵活性，这也是PyTorch 对比Tensorflow 最大的优势。

（3）PyTorch 的设计思路是线性、直观且易于使用的，当你执行一行代码时，它会忠实地执行，并没有异步的世界观，所以当你的代码出现Bug 的时候，可以通过这些信息轻松快捷地找到出错的代码，不会让你在Debug 的时候因为错误的指向或者异步和不透明的引擎浪费太多的时间。

（4）PyTorch 的代码相对于Tensorflow 而言，更加简洁直观，同时对于Tensorflow高度工业化的很难看懂的底层代码，PyTorch 的源代码就要友好得多，更容易看懂。深入API，理解PyTorch 底层肯定是一件令人高兴的事。一个底层架构能够看懂的框架，你对其的理解会更深。

最后，我们简要总结一下PyTorch 的特点：

支持GPU；
动态神经网络；
Python 优先；
命令式体验；
轻松扩展。

拥有着如此多优点的.PyTorch 也有着它的缺点，首先PyTorch 于2017 年3 月开源发布，目前还是beta 测试版，没有发布正式版本，所以可能有一些小的Bug；其次因为这款框架比较新，所以使用的人也就比较少，这也就使得它的社区没有那么强大，但是PyTorch 提供了一个官方的论坛，大多数碰到的问题都可以去里面搜索，里面的答案一般都是由作者或者其他PyTorch 使用者提供的，论坛的更新也特别频繁，同时也可以去Github 上面提Issue，一般很快就会得到开发者的回应，也算是一定程度上解决了社区的问题。

Pytorch的安装

我用的是 windows cmd 命令行 输入 activate 启动 anaconda
我的是Python3.5(Anaconda4.2)+CUDA8.0+windows10，当然如果电脑没有GPU，CUDA就选none。
由于我没有 gpu 所以 命令是 conda install pytorch -c pytorch

然后选择 y， 继续

安装完成以后启动 jupyter-notebook

pytorch 版本 1.0.1 Flase 表示不支持 gpu
如果需要 安装支持 gpu的 pytorch
命令是：conda install pytorch cuda80 -c pytorch
安装好后Pytorch后，还有个torchvision安装，这个主要集成了一些数据集，深度学习模型，一些转换等，以后需要使用还是很方便的。
pip3 install torchvision

PyTorch基础概念

1.基本数据类型和基本运算
1.1 张量
python导入pytorch为：
import torch
在torch中，常量通常表示成张量的类型(Tensor)，与numpy中的array类似。创建一个5行3列的随机初始化张量矩阵为：

1.2 基本运算

可以直接用运算符，也可以直接用函数，如计算x+y
import torch
x = torch.randn(5,3)
y = torch.rand(5,3)
z = x+y
#或者
z = torch.Tensor(5,3)
torch.add(x,y,out=z)

改变自身值的运算，需要在函数后加_，如自加
y.add_(x)

1.3 与numpy互相转换

1.4 变量Variable

相当于tensorflow中的placeholder,由autograd包引入，这个包可以计算所有Tensor的梯度信息，定义好变量后，用backward()就可以自动计算梯度

变量

Variable 的参数：data是变量的初始值，grad是梯度值，grad_fn是计算梯度的函数，例：定义一个[2,2]的变量，初始值为1，并包含梯度
import torch
from torch.autograd import Variable
x = Variable(torch.ones(2, 2), requires_grad=True)

通用代码实现流程(实现一个深度学习的代码流程)

我们以手写体识别的LeNet为例，说明pytorch写神经网络结构的框架,神经网络的有关运算有nn引入，相关函数由nn.functional引入：

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

首先定义LeNet,一个完整的模型定义如下：

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:]#切片0里面放的是当前训练batch的number，不是特征信息
num_features=1
for s in size:
num_features*=s
return num_features

net=Net()

包括类的构造函数和前向计算，构造函数就是自己定义的一些运算层，参数是随机初始化的，前向计算则是层之间的运算，反向传播相关运算则是模型自动定义。注意到的是，输入到模型中做前向计算的一定是一个Variable

其次利用定义好的网络做一次前向计算
input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)

接着初始化网络中所有参数的梯度，然后用随机的梯度做一次反向传播
net.zero_grad()
out.backward(torch.randn(1, 10))

神经网络的参数是要用训练数据去训练的，这就需要定义loss funtion，pytorch中的nn模块内定义了各种loss function
，torch中的loss function 包含输出和目标值。手写体字符有10个元素，我们就用1-10来表示，定义loss如下：
output = net(input)
target = Variable(torch.arange(1, 11)) # a dummy target, for example
target = target.view(1, -1) # make it the same shape as output
criterion = nn.MSELoss()
loss = criterion(output, target)

利用loss做一次反向传播就可以求出所有参数的梯度值，一般在计算定义loss后，先初始化所有参数的梯度值，再更新梯度。我们知道，梯度下降法只是求解优化问题中的参数的一种方法。其他方法还有Adam, RMSProp等。
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

1.6 简单的分类网络架构
一个完整的分类网络包括：读取数据→展示数据样例→定义网络结构→定义loss和优化方法→训练网络→测试网络。以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)))

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)))

定义网络结构以类的形式定义包括架构和前向计算
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()
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()
查看模型信息
有时候想要查看模型的信息，并打印出某些层的参数(weights,bias)，可以用以下语句：
params=net.state_dict()
for k,v in params.items():
print(k) #打印网络中的变量名
print(params[‘conv1.weight’]) #打印conv1的weight
print(params[‘conv1.bias’]) #打印conv1的bias

定义loss函数和优化方法
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
    inputs, labels = data

    # wrap them in Variable
    inputs, labels = Variable(inputs), Variable(labels)

    # 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.data[0]
    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’)

测试网络
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)))
outputs = net(Variable(images))

预测

_, predicted = torch.max(outputs.data, 1)
print('Predicted: ‘, ’ ‘.join(’%5s’ % classes[predicted[j]]
for j in range(4)))