Pytorch学习资源推荐：
Pytorch Tutorials :Welcome to PyTorch Tutorials
PyTorch 学习笔记：(开篇词)PyTorch 学习笔记 - PyTorch 学习笔记
PyTorch 中文教程 & 文档：PyTorch 中文教程 & 文档
Pytorch60分钟快速入门：PyTorch 60分钟快速入门
Pytorch 中文文档：主页 - PyTorch中文文档
动手学CV-Pytorch: 动手学CV-Pytorch
目录
Pytorch操作思维导图
导图转载：pytorch入坑一 | Tensor及其基本操作 - 知乎
什么是pytorch
它是一个基于python的科学计算包，针对两类受众：
- 可以代替Numpy从而利用GPU的强大功能；
- 是一个可以提供最大灵活性和速度的深度学习研究平台。
开始
张量Tensor
张量类似于Numpy中的ndarrays，此外张量可以在GPU上使用以加速计算。
from __future__ import print_function
import torch
注意：声明的未初始化的矩阵，在使用之前将不包含明确的已知值。当创建一个未初始化的矩阵时，当时在分配内存中的任何值都将作为初始值出现。
构建一个5x3的未初始化矩阵：
x = torch.empty(5, 3)
print(x)
输出：
tensor([[1.4013e-43, 4.4842e-44, 1.5975e-43],
[1.6395e-43, 1.5414e-43, 1.6115e-43],
[4.4842e-44, 1.4433e-43, 1.5975e-43],
[1.4153e-43, 1.3593e-43, 1.6255e-43],
[4.4842e-44, 1.5554e-43, 1.5414e-43]])
构建随机初始化的矩阵：
x = torch.rand(5, 3)
print(x)
输出：
tensor([[0.5609, 0.0796, 0.9257],
[0.5687, 0.6893, 0.2980],
[0.7573, 0.1314, 0.8814],
[0.8589, 0.7945, 0.0682],
[0.5252, 0.0355, 0.1465]])
构建全零且类型为long的矩阵：
x = torch.zeros(5, 3, dtype=torch.long)
print(x)
输出：
tensor([[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
直接根据数据创建张量：
x = torch.tensor([5.5, 3])
print(x)
输出：
tensor([5.5000, 3.0000])
或者基于现有的张量创建一个新的张量。如果用户没有提供新的值，则这两种创建方法将重用输入张量的属性，如数据类型。
x = x.new_ones(5, 3, dtype=torch.double) # new_* methods take in sizes
print(x)
x = torch.randn_like(x, dtype=torch.float) # override dtype!
print(x) # result has the same size
输出：
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]], dtype=torch.float64)
tensor([[ 0.9228, 0.4648, 0.9809],
[ 0.3880, 1.1388, -0.3020],
[ 1.5349, -0.5819, 0.0219],
[ 0.5549, 1.1202, -0.1401],
[ 1.5410, 0.0499, -0.0484]])
获取张量大小：
print(x.size())
输出：
torch.Size([5, 3])
torch.Size实际上是一个元组，所以它支持所有的元组操作。
操作Operations
操作支持多种语法。在下面的示例中，将先查看加法操作。
- 加法：语法1
y = torch.rand(5, 3)
print(x + y)
输出：
tensor([[ 0.4719, 0.3090, -0.3895],
[-1.2460, -0.6719, 2.4085],
[-1.0253, 1.7267, 1.8661],
[ 1.0923, 1.1947, -0.3916],
[ 1.2984, 0.7781, 2.1696]])
- 加法：语法2
print(torch.add(x, y))
输出：
tensor([[ 0.4719, 0.3090, -0.3895],
[-1.2460, -0.6719, 2.4085],
[-1.0253, 1.7267, 1.8661],
[ 1.0923, 1.1947, -0.3916],
[ 1.2984, 0.7781, 2.1696]])
- 加法：提供一个输出张量作为参数
result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)
输出：
tensor([[ 0.4719, 0.3090, -0.3895],
[-1.2460, -0.6719, 2.4085],
[-1.0253, 1.7267, 1.8661],
[ 1.0923, 1.1947, -0.3916],
[ 1.2984, 0.7781, 2.1696]])
- 加法：在位in-place（直接更新原有的张量）
# adds x to y
y.add_(x)
print(y)
输出：
tensor([[ 0.4719, 0.3090, -0.3895],
[-1.2460, -0.6719, 2.4085],
[-1.0253, 1.7267, 1.8661],
[ 1.0923, 1.1947, -0.3916],
[ 1.2984, 0.7781, 2.1696]])
通过在位改变张量的任意操作都是以后缀"_"结尾的，如
x.copy_(y), x.t_()都会改变x。
- 可以使用标准的类似于Numpy的索引实现所有功能！
print(x[:, 1])
输出：
tensor([0.4648, 1.1388, -0.5819, 1.1202, 0.0499])
- 改变大小：如果想改变张量的大小或性状，可以通过torch.view实现：
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])
- 如果张量中只有一个元素，可以通过.item()获取值作为Python数字
x = torch.randn(1)
print(x)
print(x.item())
输出：
tensor([0.2687])
0.26873132586479187
更多张量操作，包括转置（transposing）、索引（indexing）、切片（slicing）、数学操作（mathematical operations）、线性代数（liner algebra）、随机数（random numbers）等，可以点击这里。
NumPy Bridge
NumPy Bridge的作用是实现Torch张量与Numpy array之间的相互转化。
torch的Tensor和numpy的array分享底层的内存地址（如果Torch 张量位于CPU上），所以改变其中一个就会改变另一个。
Tensor 转化为Array
a = torch.ones(5)
print(a)
输出：
tensor([1., 1., 1., 1., 1.])
通过.numpy()直接得到array。
b = a.numpy()
print(b)
输出：
[1. 1. 1. 1. 1.]
查看numpy数组的值是如何变化的。
a.add_(1)
print(a)
print(b)
输出：
tensor([2., 2., 2., 2., 2.])
[2. 2. 2. 2. 2.]
可以看出a和b都发生了变化。
Array 转化为Tensor
看看如何改变np数组自动改变Torch张量的。
import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)
输出：
[2. 2. 2. 2. 2.]
tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
通过from_numpt()可以将array转化为tensor，同时改变数组的值对应的张量也会自动改变。
CUDA Tensors
可以通过.to方法将张量移动到其他设备上。
# let us run this cell only if CUDA is available
# We will use ``torch.device`` objects to move tensors in and out of GPU
if torch.cuda.is_available():
device = torch.device("cuda") # a CUDA device object
y = torch.ones_like(x, device=device) # directly create a tensor on GPU
x = x.to(device) # or just use strings ``.to("cuda")``
z = x + y
print(z)
print(z.to("cpu", torch.double)) # ``.to`` can also change dtype together!
输出：
tensor([0.8383], device='cuda:0')
tensor([0.8383], dtype=torch.float64)Tensor的基本数据类型：
- 32位浮点型：torch.FloatTensor。 (默认)
- 64位整型：torch.LongTensor。
- 32位整型：torch.IntTensor。
- 16位整型：torch.ShortTensor。
- 64位浮点型：torch.DoubleTensor。
- byte、char型
利用pytorch对矩阵的操作
# 创建一个5*3的矩阵，未初始化
matrix_1 = torch.empty(5, 3)
print(matrix_1)
# 沿着行，取最大值
max_value, max_idx = torch.max(matrix_1, dim=1)
print(max_value, max_idx) # tensor([-0.0826, 1.9343, 0.7472, 0.9369, 0.1643]) tensor([0, 1, 0, 1, 1])
# 每行求和
sum_matrix = torch.sum(matrix_1, dim=1)
print(sum_matrix) # tensor([ 0.6769, -0.7962, 1.6030, -0.0475, -2.7280])
# 创建一个随机初始化的矩阵
matrix_2 = torch.rand(5, 3)
print(matrix_2)
# 创建一个0填充的矩阵，dtype指定数据类型为long
matrix_3 = torch.zeros(5, 3, dtype=torch.long)
print(matrix_3)
pytorch创建tensor
- tensor（张量）
通俗认为，零阶张量是标量，一阶张量是矢量，二阶张量是矩阵。。。 从工程角度可以认为是一个数、一维数组、二维数组以及高维数据。pytorch中的tensor可认为是一个高维数组。且和Numpy中的 ndarrays 类似
# 创建tensor（张量），并使用现有的数据初始化
# 张量。零阶张量是标量，一阶张量是矢量，二阶张量是矩阵。。。
matrix_4 = torch.tensor([5.5, 3])
print(matrix_4)
# 根据现有的tensor创建tensor，dtype当设置新的值时覆盖旧值。new_ones()方法创建全1的tensor
matrix_5 = matrix_4.new_ones(5, 3, dtype=torch.double)
print(matrix_5)
# 形状与matrix_5，相同的随机矩阵
matrix_6 = torch.randn_like(matrix_5, dtype=torch.float)
print(matrix_6)
初始化方法：
- torch.rand(5, 3) 【使用[0,1]均匀分布，随机初始化5*3的二维数组】
- torch.ones(2, 2) 【内容全1的2*2矩阵】
- torch.zeros(2,2) 【内容全0的2*2矩阵】
- torch.eye(2,2)【单位矩阵 2*2】
size()方法与Numpy中的shape属性返回的相同，同时tensor也支持shape属性。size()返回值是tuple类型，支持tuple类型的所有操作。
print(matrix_6.size()) # torch.Size([5, 3])
pytorch运算
- 加法
变量1+变量2并赋值给变量3
# 加法。法一
matrix1_1 = torch.rand(5, 3)
matrix1_2 = matrix1_1 + matrix_6
print(matrix1_2)
# 法二
matrix1_3 = torch.add(matrix1_1, matrix_6)
print(matrix1_3)
# 法三
result = torch.empty(5, 3)
# out指定 结果存到result变量中
torch.add(matrix1_1, matrix_6, out=result)
变量1和变量2的和，替换其中某个变量。
注：以“_”结尾的操作都会用结果替换原变量。例如x.copy_(y), x.t_(), 都会改变 x.
# adds matrix_6 to result
result.add_(matrix_6)
print(result)
索引
matrix_1 = torch.rand(5, 3)
# tensor列标为1的元素。即tensor的第二列元素
print(matrix_1[:, 1])
torch.view可以改变tensor的维度和大小。与Numpy的reshape类似
# torch.view可以改变tensor的维度和大小
matrix_2 = torch.randn(4, 4)
matrix_3 = matrix_2.view(16)
matrix_4 = matrix_2.view(-1, 8) # -1 表示从其他维度推断。即已知列为8，推断行
print(matrix_2.size(), matrix_3.size(), matrix_4.size()) # torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
当tensor只有一个元素或是标量时，使用item()可得到其值
matrix_5 = torch.randn(1)
# 得到python数据类型的数值
matrix_5_value = matrix_5.item()
pytorch与numpy
当torch tensor和numpy相互转换时，它们两个共享底层的内存地址，即修改一个会导致另一个的变化。
注：CharTensor 类型不支持到 NumPy 的转换.
# 全1。1行5列
a = torch.ones(5)
print(a) # tensor([1., 1., 1., 1., 1.])
# torch tensor转为numpy
b = a.numpy()
print(b) # [1. 1. 1. 1. 1.]
a.add_(2)
print(a) # tensor([3., 3., 3., 3., 3.])
print(b) # [3. 3. 3. 3. 3.]
x = np.ones(5) # [1. 1. 1. 1. 1.]
# numpy转为torch tensor
y = torch.from_numpy(x) # tensor([1., 1., 1., 1., 1.], dtype=torch.float64)
np.add(x, 1, out=x)
print(x) # [2. 2. 2. 2. 2.]
print(y) # tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
Autograd: 自动求导机制
在张量创建时，通过设置requires_grad 为 True，对该张量自动求导，会追踪所有对于该张量的操作。每个张量有grad_fn属性，记录了创建这个Tensor类的Function对象。
# 2*2 全1 追踪计算历史
matrix_1 = torch.ones(2, 2, requires_grad=True)
matrix_2 = matrix_1 + 2
# grad_fn被创建，表示和存储了完整的计算历史
print(matrix_2)
print(matrix_2.grad_fn) # <AddBackward0 object at 0x0000022E29309160>
matrix_3 = matrix_2 * matrix_2 * 3
# 平均数
out = matrix_3.mean()
print(matrix_3)
print(out)
执行结果如下：
requires_grad属性，如果没有指定的话，默认输入的flag是 False。可是使用requires_grad_()来修改。
matrix_a = torch.randn(2, 2)
matrix_b = ((matrix_a * 3) / (matrix_a - 1))
print(matrix_b)
# 改变源张量的设置。
matrix_a.requires_grad_(True)
print(matrix_a.requires_grad)
matrix_c = (matrix_a * matrix_a).sum()
print(matrix_c)
当完成计算后通过调用backward()方法，自动计算所有的梯度，并且这个张量的所有梯度将会自动积累到grad 属性。这个过程的具体步骤（假设x,y经过计算操作得到结果z）：
- 执行z.backward()，将调用z中的grad_fn属性，执行求导操作。
- 遍历grad_fn中的next_functions，分别取出里边的Function，执行求导操作。这部分是一个递归过程，直到最后的类型为叶子节点。
- 计算出结果后，将结果存在对应的variable这个变量所引用的对象（x，y）的grad属性中。
- 求导结束。所有叶节点的grad更新。
在代码中，计算结果的元素多少，会对backward()的参数有要求，分为两种情况，标量/非标量，如下：
- 计算结果为一个标量时的梯度操作
matrix_1 = torch.ones(2, 2, requires_grad=True)
matrix_2 = matrix_1 + 2
matrix_3 = matrix_2 * matrix_2 * 3
# 平均数
out = matrix_3.mean()
# 当结果是一个标量时
# 完成上述计算后，调用backward()方法，自动计算所有的梯度，且该张量的所有梯度自动累积到grad属性
print(out.backward()) # None
print(matrix_1.grad)
- 计算结果不是标量时的操作。需要指定一个gradient参数，这是形状匹配的张量，输入一个大小相同的张量作为参数。（可使用ones_like函数根据源，来生成一个张量）
matrix_x = torch.randn(3, requires_grad=True)
matrix_y = matrix_x * 2
while matrix_y.data.norm() < 1000:
matrix_y = matrix_y * 2
# 此时计算结果不再是一个标量
print(matrix_y)
# 创建一个向量作为参数，传入backward中。向量大小与matrix_x一致
gradients = torch.ones_like(matrix_x)
matrix_y.backward(gradients)
print(matrix_x.grad)
若requires_grad=True，但是又不希望进行autograd的计算， 那么可以将变量包裹在 with torch.no_grad()中，这种方法在测试集计算准确率时会用到。
print(matrix_1.requires_grad) # True
print((matrix_1 ** 2).requires_grad) # True
with torch.no_grad():
print((matrix_1 ** 2).requires_grad) # False
注：若要扩展autograd，需要扩展Function类，重写forward()和backward()，且必须是静态方法。
神经网络（Neural Networks）
典型训练过程如下：
- 定义包含一些可学习的参数（或叫权重）神经网络模型
- 数据集上迭代
- 通过NN来处理输入
- 计算损失（输出结果和正确值的差值大小）
- 将梯度反向传播回网络的参数
- 更新网络参数。主要是用简单的更新原则（例： weight = weight - learning_rate * gradient）
注：torch.nn包只支持小批量样本，不支持单个样本。 如果有单个样本，需使用 input.unsqueeze(0) 来添加其它的维数。
以下这个类定义了一个网络：
import torch
import torch.nn as nn
import torch.nn.functional as F
# nn.Module包含各个层和一个forward(input)方法，该方法返回output。
class Net(nn.Module):
def __init__(self):
# nn.Module子类的函数必须在构造函数中执行父类的构造函数
super(Net, self).__init__()
# 卷积层 1-输入图片为单通道, 6-输出通道数, 5-卷积核为5*5
self.conv1 = nn.Conv2d(1, 6, 3)
# an affine operation(仿射操作): y = Wx + b
# 线性层，输入1350个特征，输出10个特征
self.fc1 = nn.Linear(1350, 10)
# 正向传播。 forward函数必须创建。可在此函数中，使用任何Tensor支持的操作
def forward(self, x):
print(x.size()) # torch.Size([1, 1, 32, 32])
# 卷积->激活->池化
# 根据卷积的尺寸计算公式，结果为30？
x = self.conv1(x)
x = F.relu(x)
print(x.size()) # torch.Size([1, 6, 30, 30])
# 使用池化层，结果15？
x = F.max_pool2d(x, (2, 2))
x = F.relu(x)
print(x.size()) # torch.Size([1, 6, 15, 15])
# reshape -1表示自适应
# 压扁
x = x.view(x.size()[0], -1)
print(x.size()) # torch.Size([1, 1350])
x = self.fc1(x)
return x
# 神经网络
def neural_networks():
# ☆ 定义一个网络
net = nn_learning.Net()
print(net)
# net.parameters()返回可被学习的参数（权重）列表和值
params = list(net.parameters())
print(len(params))
# conv1's weight
print(params[0].size())
# ☆ 处理输入
# 参数中的四个数，指定每一层[]中的数量
# 随机指定输入
input = torch.randn(1, 1, 32, 32)
# 得到输出
out = net(input)
print(out.size()) # torch.Size([1, 10])
# ☆ 调用backward
# 将所有参数的梯度缓存清零
net.zero_grad()
# 随机梯度的反向传播
out.backward(torch.randn(1, 10))
损失函数接收一对（output，target）作为输入，计算一个值来估计网络的输出和目标值相差多少。
torch.nn包中有许多不同的损失函数，其中比较简单的是 nn.MSELoss()，它计算output和target之间的均方误差。
# 损失函数
output = net(input)
# 以一个随机值作为target
target = torch.randn(10)
# 使target和output的shape相同
target = target.view(1, -1)
criterion = torch.nn.MSELoss()
loss = criterion(output, target)
print(loss) # tensor(0.5446, grad_fn=<MseLossBackward>)
调用loss.backward()获得反向传播的误差。调用前需要清除已存在的梯度，否则梯度会累加到已存在的梯度。
# 反向传播。获得反向传播的误差
# 清除梯度
net.zero_grad()
# 查看conv1层的bias项在反向传播前后的梯度
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad) # tensor([0., 0., 0., 0., 0., 0.])
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad) # tensor([ 0.0087, -0.0126, 0.0076, 0.0002, 0.0021, -0.0032])
更新权重中最简单的权重更新规则是随机梯度下降（SGD）：weight = weight - learning_rate * gradient
torch.optim包中实现了各种不同的更新规则（SGD、Nesterov-SGD、Adam、RMSPROP等）
例：
# create optimizer
optimizer = torch.optim.SGD(net.parameters(), lr=0.01)
# 梯度清零
optimizer.zero_grad()
loss.backward()
# 更新
optimizer.step()
数据加载和预处理
torch.utils.data对一般常用的数据加载进行了封装，可以很容易地实现多线程数据预读和批量加载。
我们可以自定义数据集，并且可以实例一个对象来访问：
from torch.utils.data import Dataset
import pandas as pd
# 定义一个数据集。继承Dataset
class BulldozerDataset(Dataset):
"""数据集演示"""
def __init__(self, csv_file):
"""实现初始化方法，初始化时将数据载入"""
self.df = pd.read_csv(csv_file)
def __len__(self):
"""返回df长度"""
return len(self.df)
def __getitem__(self, idx):
"""根据idx返回一行数据"""
return self.df.iloc[idx].SalePrice
if __name__ == "__main__":
ds_demo = BulldozerDataset('median_benchmark.csv')
print(len(ds_demo))
数据载入器DataLoader为我们提供了对Dataset的读取操作。常用参数：
- batch_size——每个batch的大小，默认1
- shuffle——是否进行shuffle操作【打乱顺序】，默认False
- num_workers——加载数据的时候使用几个子进程，默认0
- pin_memory——是否将数据放置到GPU上，默认False
# DataLoader 返回可迭代对象
dl = torch.utils.data.DataLoader(ds_demo, batch_size=10, shuffle=True, num_workers=0)
# 使用迭代器分次获取数据
idata = iter(dl)
print(next(idata))
# 或者用for循环
for i, data in enumerate(dl):
print(i, data)