【Task1(2天)】PyTorch的基本概念

1、什么是Pytorch，为什么选择Pytroch？
PyTorch是使用GPU和CPU优化的深度学习张量库
PyTorch是美国互联网巨头Facebook在深度学习框架Torch的基础上使用Python重写的一个全新的深度学习框架，它更像NumPy的替代产物，不仅继承了NumPy的众多优点，还支持GPUs计算，在计算效率上要比NumPy有更明显的优势；不仅如此，PyTorch还有许多高级功能，比如拥有丰富的API，可以快速完成深度神经网络模型的搭建和训练。所以 PyTorch一经发布，便受到了众多开发人员和科研人员的追捧和喜爱，成为AI从业者的重要工具之一。
为什么选择Pytroch，因为PyTorch是当前难得的简洁优雅且高效快速的框架。
2、Pytroch的安装
3、配置Python环境
4、准备Python管理器
5、通过命令行安装PyTorch
win7+anaconda+pytorch
https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/win-64/下载pytorch-cpu-1.1.0-py3.6_cpu_1.tar.bz2
创建环境：conda create -n pytorch1135
conda activate pytorch1135
python版本3.5
conda install numpy mkl cffi
安装后python版本变为3.7
conda install --offline pytorch-cpu-1.1.0-py3.7_cpu_1.tar.bz2
如何在 Jupyter Notebook 中使用 PyTorch参考https://www.jianshu.com/p/da89fb397ef6
conda install ipython
conda install jupyter
ipython kernelspec install-self --user
mkdir -p /home/gcb/.ipython/kernels
mv /home/gcb/.local/share/jupyter/kernels/python3　/home/gcb/.ipython/kernels/pytorch_kernel
6、PyTorch基础概念
参考：https://www.cnblogs.com/wj-1314/p/9830950.html

7、通用代码实现流程(实现一个深度学习的代码流程)
一个典型的神经网络训练过程包括以下几点：

（1） 定义一个包含可训练参数的网络
（2） 迭代整个输入
（3） 通过神经网络处理输入
（4）计算损失（loss）
（5） 反向传播梯度到神经网络的参数
（6）更新网络的参数：weight=weight-learning_rate*gradient

以下引用 https://github.com/chenyuntc/pytorch-book/blob/master/chapter2-快速入门/chapter2: PyTorch快速入门.ipynb

定义网络
定义网络时，需要继承nn.Module，并实现它的forward方法，把网络中具有可学习参数的层放在构造函数__init__中。如果某一层(如ReLU)不具有可学习的参数，则既可以放在构造函数中，也可以不放，但建议不放在其中，而在forward中使用nn.functional代替。

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

class Net(nn.Module):
def init(self):
# nn.Module子类的函数必须在构造函数中执行父类的构造函数
# 下式等价于nn.Module.init(self)
super(Net, self).init()

    # 卷积层 '1'表示输入图片为单通道, '6'表示输出通道数，'5'表示卷积核为5*5
    self.conv1 = nn.Conv2d(1, 6, 5) 
    # 卷积层
    self.conv2 = nn.Conv2d(6, 16, 5) 
    # 仿射层/全连接层，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): 
    # 卷积 -> 激活 -> 池化 
    x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
    x = F.max_pool2d(F.relu(self.conv2(x)), 2) 
    # reshape，‘-1’表示自适应
    x = x.view(x.size()[0], -1) 
    x = F.relu(self.fc1(x))
    x = F.relu(self.fc2(x))
    x = self.fc3(x)        
    return x

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, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
只要在nn.Module的子类中定义了forward函数，backward函数就会自动被实现(利用autograd)。在forward 函数中可使用任何tensor支持的函数，还可以使用if、for循环、print、log等Python语法，写法和标准的Python写法一致。

网络的可学习参数通过net.parameters()返回，net.named_parameters可同时返回可学习的参数及名称。

params = list(net.parameters())
print(len(params))
10

for name,parameters in net.named_parameters():
print(name,’:’,parameters.size())
conv1.weight : torch.Size([6, 1, 5, 5])
conv1.bias : torch.Size([6])
conv2.weight : torch.Size([16, 6, 5, 5])
conv2.bias : torch.Size([16])
fc1.weight : torch.Size([120, 400])
fc1.bias : torch.Size([120])
fc2.weight : torch.Size([84, 120])
fc2.bias : torch.Size([84])
fc3.weight : torch.Size([10, 84])
fc3.bias : torch.Size([10])
forward函数的输入和输出都是Tensor。

input = t.randn(1, 1, 32, 32)
out = net(input)
out.size()
Out[37]:
torch.Size([1, 10])

net.zero_grad() # 所有参数的梯度清零
out.backward(t.ones(1,10)) # 反向传播
需要注意的是，torch.nn只支持mini-batches，不支持一次只输入一个样本，即一次必须是一个batch。但如果只想输入一个样本，则用 input.unsqueeze(0)将batch_size设为１。例如 nn.Conv2d 输入必须是4维的，形如$nSamples\times nChannels\times Height\times Width$。可将nSample设为1，即$1\times nChannels\times Height\times Width$。

损失函数
nn实现了神经网络中大多数的损失函数，例如nn.MSELoss用来计算均方误差，nn.CrossEntropyLoss用来计算交叉熵损失。

output = net(input)
target = t.arange(0,10).view(1,10)
criterion = nn.MSELoss()
loss = criterion(output, target)
loss # loss是个scalar
Out[39]:
tensor(28.5625)
如果对loss进行反向传播溯源(使用gradfn属性)，可看到它的计算图如下：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss
当调用loss.backward()时，该图会动态生成并自动微分，也即会自动计算图中参数(Parameter)的导数。

运行.backward，观察调用之前和调用之后的grad

net.zero_grad() # 把net中所有可学习参数的梯度清零
print(‘反向传播之前 conv1.bias的梯度’)
print(net.conv1.bias.grad)
loss.backward()
print(‘反向传播之后 conv1.bias的梯度’)
print(net.conv1.bias.grad)
反向传播之前 conv1.bias的梯度
tensor([ 0., 0., 0., 0., 0., 0.])
反向传播之后 conv1.bias的梯度
tensor(1.00000e-02 *
[-2.2701, -1.8687, 4.3639, -2.9262, -4.3535, -5.9584])
优化器
在反向传播计算完所有参数的梯度后，还需要使用优化方法来更新网络的权重和参数，例如随机梯度下降法(SGD)的更新策略如下：

weight = weight - learning_rate * gradient
手动实现如下：

learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)# inplace 减法
torch.optim中实现了深度学习中绝大多数的优化方法，例如RMSProp、Adam、SGD等，更便于使用，因此大多数时候并不需要手动写上述代码。

import torch.optim as optim
#新建一个优化器，指定要调整的参数和学习率
optimizer = optim.SGD(net.parameters(), lr = 0.01)

在训练过程中

先梯度清零(与net.zero_grad()效果一样)

optimizer.zero_grad()

计算损失

output = net(input)
loss = criterion(output, target)

#反向传播
loss.backward()

#更新参数
optimizer.step()
数据加载与预处理
在深度学习中数据加载及预处理是非常复杂繁琐的，但PyTorch提供了一些可极大简化和加快数据处理流程的工具。同时，对于常用的数据集，PyTorch也提供了封装好的接口供用户快速调用，这些数据集主要保存在torchvison中。

torchvision实现了常用的图像数据加载功能，例如Imagenet、CIFAR10、MNIST等，以及常用的数据转换操作，这极大地方便了数据加载，并且代码具有可重用性。

初识pytorch，还有很多不懂的，近期弄明白