从细节过渡到实例 一天学会Pytorch
Posted 白水baishui
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了从细节过渡到实例 一天学会Pytorch相关的知识，希望对你有一定的参考价值。
文章目录
1. PyTorch基础
1.1. 导入PyTorch包
import torch
1.2. 张量的初始化
(1) 创建并初始化张量
# 创建一个任意张量
tensor = torch.tensor([5.5, 3, 0])
'''
tensor([5.5000, 3.0000, 0.0000])
'''
# 创建一个数列张量，从1开始，到10结束，间隔为2
tensor_arange = torch.arange(1, 10, 2)
'''
tensor([1, 3, 5, 7, 9])
'''
# 创建一个空张量，大小为 5*3
tensor_empty = torch.empty((5, 3))
'''
tensor([[7.1819e+22, 4.0666e+21, 1.0999e+27],
[2.6277e+17, 7.2368e+25, 2.7516e+17],
[4.4721e+21, 1.8497e+31, 2.6845e+17],
[4.4724e+21, 1.8497e+31, 5.4214e-11],
[9.1720e-04, 1.9086e-41, 0.0000e+00]])
'''
# 创建一个0张量，大小为 5*3
tensor_zeros = torch.zeros((5, 3))
'''
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
'''
# 创建一个1张量，大小为 5*3
tensor_ones = torch.ones((5, 3))
'''
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
'''
# 创建一个任意值张量，大小为 5*3，填充值为99
tensor_full = torch.full([5, 3], 99.)
'''
tensor([[99., 99., 99.],
[99., 99., 99.],
[99., 99., 99.],
[99., 99., 99.],
[99., 99., 99.]])
'''
# 创建一个在[0,1)内均匀分布的随机张量，大小为 5*3
tensor_rand = torch.rand((5, 3))
'''
tensor([[0.4991, 0.5687, 0.9626],
[0.3185, 0.2407, 0.6076],
[0.2600, 0.0289, 0.1632],
[0.4269, 0.9201, 0.4774],
[0.7576, 0.9349, 0.5644]])
'''
# 创建一个服从标准正态分布的随机张量，大小为 5*3
tensor_randn = torch.randn((5, 3))
'''
tensor([[-0.6753, -1.6975, -1.1010],
[-1.9736, 0.6005, 0.5844],
[ 0.3015, -0.5700, 1.1196],
[ 0.3156, -0.4194, -0.8618],
[-1.1506, 0.5248, 0.0401]])
'''
# 创建一个服从均值为mean、标准差为std正态分布的随机张量，大小为 1*10
# 更多关于随机正态分布张量的内容：https://pytorch.org/docs/stable/generated/torch.normal.html#torch-normal
tensor_normal = torch.normal(mean=torch.arange(0., 1.), std=torch.arange(0, 10, 1))
'''
tensor([ 0.0000, -0.9662, -0.2848, 5.5105, 0.9495, 3.0639, -3.4798,
6.9719, -11.6149, -6.0056])
'''
(2) 从已有张量创建大小一致的张量
# 根据已有的张量创建大小一致的0张量
tensor_zeros = torch.zeros_like(tensor_empty)
'''
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
'''
# 根据已有的张量创建大小一致的1张量
tensor_ones = torch.ones_like(tensor_empty)
'''
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
'''
# 根据已有的张量创建大小一致在[0,1)内的均匀分布的随机张量
tensor_rand = torch.rand_like(tensor_empty)
'''
tensor([[0.0437, 0.9776, 0.1685],
[0.5190, 0.6811, 0.3768],
[0.4864, 0.7169, 0.4813],
[0.4596, 0.4703, 0.2497],
[0.9778, 0.9880, 0.9152]])
'''
(3) 指定张量的数据类型 dtype
# 创建long数据类型的张量
tensor_long = torch.ones((5, 3), dtype=torch.long)
'''
tensor([[1, 1, 1, 1, 1]])
'''
# 查看张量的数据类型
print(tensor_long.dtype)
'''
torch.int64
'''
# 改变张量的数据类型
print(tensor_long.float())
'''
torch.float32
'''
# 张量的数据类型总结：
# 8位无符号整型：torch.uint8
# 8位整型：torch.int8
# 16位整型：torch.int16 | torch.short
# 32位整型：torch.int32 | torch.int
# 64位整型：torch.int64 | torch.long
# 16位浮点型：torch.float16 | torch.half
# 32位浮点型：torch.float32 | torch.float
# 64位浮点型：torch.float64 | torch.double
1.3. 张量的基本操作
(1) 查看张量的大小
tensor_empty = torch.empty((5, 3))
print(tensor_empty.size())
'''
torch.Size([5, 3])
'''
print(tensor_empty.shape)
'''
torch.Size([5, 3])
'''
(2) 张量堆叠
# 创建一个空张量，大小为 5*3
tensor_empty = torch.tensor([[1,2,3]])
'''
tensor([[1, 2, 3]])
'''
# 张量按维度0堆叠，即添加行
tensor_cat0 = torch.cat((tensor_empty,tensor_empty,tensor_empty), 0)
'''
tensor([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
'''
# 张量按维度0堆叠，即添加列
tensor_cat1 = torch.cat((tensor_empty,tensor_empty,tensor_empty), 1)
'''
tensor([[1, 2, 3, 1, 2, 3, 1, 2, 3]])
'''
(3) 张量增减维度
tensor_zeros = torch.zeros(3, 2, 4, 1, 2, 1)
print(tensor_zeros.shape)
'''
torch.Size([3, 2, 4, 1, 2, 1])
'''
# 在张量的第dim维增添一个维数为1的维度
tensor_unsqueeze = torch.unsqueeze(tensor_zeros, dim=0)
print(tensor_unsqueeze.shape)
'''
torch.Size([1, 3, 2, 4, 1, 2, 1])
'''
# 删去张量中维数为1的维度，如果未指定dim则删去全部维数为1的维度
tensor_squeeze = torch.squeeze(tensor_zeros, dim=3)
print(tensor_squeeze.shape)
'''
torch.Size([3, 2, 4, 2, 1])
'''
(4) 张量分割
# 创建一个数列张量
tensor_arange = torch.arange(10)
'''
tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
'''
# 把张量均匀分割。4表示分割成4份；dim=0表示按行分割，dim=1表示按列分割
tensor_chunk = torch.chunk(tensor_arange, 4, dim=0)
'''
(tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8]), tensor([9]))
'''
# 把张量按指定方案分割。[1,2,3,4]表示分割成4份，每份分别有1、2、3、4个元素；dim=0表示按行分割，dim=1表示按列分割
tensor_split = torch.split(tensor_arange, [1,2,3,4], dim=0)
'''
(tensor([0]), tensor([1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8, 9]))
'''
(5) 选择张量中的元素
# 创建一个随机张量
tensor_randn = torch.randn((5, 3))
'''
tensor([[ 0.3567, 1.3366, 0.1045],
[ 0.7795, -0.2843, -0.2252],
[-0.4905, -0.2118, -1.5967],
[ 0.8375, 0.3417, -0.7932],
[-0.5923, -2.4375, -0.9357]])
'''
# 取张量的(0,0)元素
print(tensor_randn[0, 0])
'''
tensor(0.3567)
'''
# 取张量的第一列元素
print(tensor_randn[:, 0])
'''
tensor([ 0.3567, 0.7795, -0.4905, 0.8375, -0.5923])
'''
# 选择张量中行index为0、2、4的元素
print(torch.index_select(tensor_randn, dim=0, index=torch.tensor([0, 2, 4])))
'''
tensor([[ 0.3567, 1.3366, 0.1045],
[-0.4905, -0.2118, -1.5967],
[-0.5923, -2.4375, -0.9357]])
'''
# 选择张量中>=0的元素，mask为条件表达式
print(torch.masked_select(tensor_randn, mask=tensor_randn.ge(0)))
'''
tensor([0.3567, 1.3366, 0.1045, 0.7795, 0.8375, 0.3417])
'''
(6) 改变张量形状
# 创建一个随机张量
tensor_randn = torch.randn((5, 3))
'''
tensor([[ 0.3478, -2.1573, 0.7693],
[-0.3915, -1.2390, -0.7590],
[-0.3685, 0.1261, 0.1424],
[ 0.5710, 0.0483, -1.2647],
[-0.8762, 0.9870, -0.0174]])
'''
# 将tensor_randn从(5,3)转变为(3,5)
tensor_reshape = torch.reshape(tensor_randn, (3,5))
'''
tensor([[ 0.3478, -2.1573, 0.7693, -0.3915, -1.2390],
[-0.7590, -0.3685, 0.1261, 0.1424, 0.5710],
[ 0.0483, -1.2647, -0.8762, 0.9870, -0.0174]])
'''
# 将tensor_randn从(5,3)转变为(3,5)
tensor_view = tensor_randn.view((-1,5)) #当某一维是-1时，会根据另一维自动计算它的大小
'''
tensor([[ 0.3478, -2.1573, 0.7693, -0.3915, -1.2390],
[-0.7590, -0.3685, 0.1261, 0.1424, 0.5710],
[ 0.0483, -1.2647, -0.8762, 0.9870, -0.0174]])
'''
(7) 张量运算
# 创建一个数列张量
tensor_arange1 = torch.arange(10, 20, 2)
tensor_arange2 = torch.arange(0, -10, -2)
'''
tensor([10., 12., 14., 16., 18.])
tensor([-1., -3., -5., -7., -9.])
'''
# 张量元素相加 + 两种方法
tensor_add = torch.add(tensor_arange1,tensor_arange2, out=None)
# torch.add(tensor_arange1,tensor_arange2, out=tensor_arange1) # 此时操作结果直接存储在tensor_arange1中
# tensor_arange2.add_(tensor_arange1) # 此时操作结果直接存储在tensor_arange2中
'''
tensor([9., 9., 9., 9., 9.])
'''
# 张量元素相乘 ×
tensor_mul = torch.mul(tensor_arange1, tensor_arange2, out=None)
'''
tensor([ -10., -36., -70., -112., -162.])
'''
# 张量元素相除 ÷ 这里要注意除法的结果一般为浮点数，所以张量类型也应当为浮点数类型
tensor_div = torch.div(tensor_arange1, tensor_arange2, out=None)
'''
tensor([-10.0000, -4.0000, -2.8000, -2.2857, -2.0000])
'''
# 张量元素求幂 ^
tensor_pow = torch.pow(tensor_arange1, tensor_arange2, out=None)
'''
tensor([1.0000e-01, 5.7870e-04, 1.8593e-06, 3.7253e-09, 5.0414e-12])
'''
# 张量元素开平方根 √
tensor_sqrt = torch.sqrt(tensor_arange1, out=None)
'''
tensor([3.1623, 3.4641, 3.7417, 4.0000, 4.2426])
'''
# 张量元素四舍五入
tensor_round = torch.round(tensor_arange1, out=None)
'''
tensor([10., 12., 14., 16., 18.])
'''
# 张量元素取绝对值
tensor_abs = torch.abs(tensor_arange2, out=None)
'''
tensor([1., 3., 5., 7., 9.])
'''
# 张量元素向上取整，等于向下取整+1
tensor_ceil = torch.ceil(tensor_arange2, out=None)
'''
tensor([-1., -3., -5., -7., -9.])
'''
# 张量元素限定值域，把输入数据规范在min-max区间，超过范围的用min、max代替
tensor_clamp = torch.clamp(tensor_arange1, min=12, max=16, out=None)
'''
tensor([12., 12., 14., 16., 16.])
'''
# 张量取最大值的下标，dim=1时取出每一列中的最大值的下标，dim=0时取出每一行中的最大值的下标
tensor_argmax = torch.argmax(tensor_arange1, dim=0, keepdim=False)
'''
tensor(4)
'''
# 张量元素输入sigmoid函数进行处理
tensor_sigmoid = torch.sigmoid(tensor_arange1, out=None)
'''
tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000])
'''
# 张量元素输入tanh函数进行处理
tensor_tanh = torch.tanh(tensor_arange1, out=None)
'''
tensor([1., 1., 1., 1., 1.])
'''
1.4. Tensor与Numpy、List的互相转换
(1) Tensor 转 Numpy 再转 List
# 创建一个1张量
tensor_ones = torch.ones((2,4))
'''
tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.]])
'''
# 将tensor张量转换为array数组
# 转换后，numpy的变量和原来的tensor会共用底层内存地址，所以如果原来的tensor改变了，numpy变量也会随之改变
tensor_numpy = tensor_ones.numpy()
'''
[[1. 1. 1. 1.]
[1. 1. 1. 1.]]
'''
tensor_list = tensor_numpy.tolist()
'''
[[1., 1., 1., 1.],
[1., 1., 1., 1.]]
'''
(2) List 转 Numpy 再转 Tensor
# 创建一个1列表
list_ones = [1 for i in range(0, 5)]
'''
[1, 1, 1, 1, 1]
'''
# 将list转换为array
array_ones = numpy.array(list_ones)
'''
[1 1 1 1 1]
'''
# 将array数组转换为tensor张量
# 转换后，tensor和原来的numpy的变量会共用底层内存地址，所以如果原来的tensor改变了，numpy变量也会随之改变
tensor_form_numpy = torch.from_numpy(array_ones)
'''
tensor([1., 1., 1., 1., 1.], dtype=torch.int)
'''
# 改变tensor的数据类型
tensor_form_numpy = tensor_form_numpy.float()
'''
tensor([1., 1., 1., 1., 1.], dtype=torch.float32)
'''
1.5. GPU加速
在Pytorch使用GPU进行加速之前，需要先安装机器显卡对应的 CUDA ，然后即可利用GPU进行运算
(1) 将数据从CPU迁入GPU
# 一般而言，我们将网络模型、损失函数、张量三种数据迁入GPU中进行加速
# 将网络模型和损失函数迁入GPU
net = Net()
loss_func = torch.nn.CrossEntropyLoss()
if(torch.cuda.is_available()):
net = net.cuda()
loss_func = loss_func.cuda()
# 将张量迁入GPU，实际上只需要将输入网络的张量数据迁入GPU即可，因为根据这些数据产生的中间数据以及预测结果均在GPU中，所以只要把握住源头数据，后面的数据就不需要再显式地迁入GPU
# 有些旧版的Pytorch需要将张量封装成Variable类型才可以迁入GPU，不过这已经是过去式了
if (torch.cuda.is_available()):
tensor_x, tensor_y = tensor_x.cuda(), tensor_y.cuda()
# tensor_x, tensor_y = Variable(tensor_x).cuda(), Variable(tensor_y).cuda() # 旧版Pytorch
(2) 将数据从GPU迁出到CPU
# 将网络模型预测的结果迁出GPU，一般是最终损失值、精确度，也可以是其他迁入了GPU的数据
if(torch.cuda.is_available()):
loss = loss.cpu()
accurate = accurate.cpu()
2. 自动微分
2.1. 开启自动微分
# 创建一个张量并在初始化时设置requires_grad=True开启自动微分功能
tensor_ones = torch.ones(2, 2, requires_grad=True)
'''
tensor([[1., 1.],
[1., 1.]], requires_grad=True)
'''
# 创建一个张量，初始化时不开启自动微分
tensor_randn = torch.randn(2, 2)
tensor_randn = (tensor_randn * 3) / (tensor_randn - 1)
print(tensor_randn.requires_grad)
# 设置该张量为自动微分
tensor_randn.requires_grad_(True)
print(tensor_randn.requires_grad)
'''
False
True
'''
2.2. 梯度计算
(1) 查看梯度方程 grad_fn
# 创建一个1张量，并查看其梯度方程grad_fn
tensor_ones = torch.ones(2, 2, requires_grad=True)
print(tensor_ones)
print(tensor_ones.grad_fn) # 可以看到，单独的张量是没有梯度方程的
'''
tensor([[1., 1.],
[1., 1.]], requires_grad=True)
None
'''
# 构建一个张量方程，并查看其梯度方程grad_fn
tensor_add = tensor_ones + 2
print(tensor_add)
print(tensor_add.grad_fn) # 该张量方程是由加法构建的张量方程，因此梯度方程是AddBackward类型的
'''
tensor([[3., 3.],
[3., 3.]], grad_fn=<AddBackward0>)
<AddBackward0 object at 0x00000245B1025CA0>
'''
# 构建一个张量方程，并查看其梯度方程grad_fn
tensor_mul = tensor_ones * tensor_ones * 2
print(tensor_mul)
print(tensor_mul.grad_fn) # 该张量方程是由乘法构建的张量方程，因此梯度方程是MulBackward类型的
'''
tensor([[2., 2.],
[2., 2.]], grad_fn=<MulBackward0>)
<MulBackward0 object at 0x000001A309525CA0>
'''
(2) 反向传播计算标量梯度
# 创建一个1张量
tensor_x = torch.ones(2, 2, requires_grad=True)
tensor_y = tensor_x + 2
tensor_z = tensor_y * tensor_y * 3
out = tensor_z.mean()
print(out)
'''
tensor(27., grad_fn=<MeanBackward0>)
'''
# 反向传播计算梯度
# out是标量，因此不需要为backward()函数指定参数,相当于out.backward(torch.tensor(1))
out.backward()
print(tensor_x.grad) # 输出梯度
'''
tensor([[4.5000, 4.5000],
[4.5000, 4.5000]])
'''
(3) 反向传播计算矢量梯度
# 创建一个随机张量
tensor_x = torch.randn((1,3), requires_grad=True)
print(tensor_x)
'''
tensor([[0.2427, 0.8484, 0.7631]], requires_grad=True)
'''
# 求 y^(2^(n))>=1000 的最小值
tensor_y = tensor_x * 2
while tensor_y.data.norm() < 1000:
tensor_y = tensor_y * 2
print(tensor_y)
'''
tensor([[248.5333, 868.7134, 781.4405]], grad_fn=<MulBackward0>)
'''
gradients = torch.tensor([[0.1, 1.0, 0.0001]], dtype=torch.float) # 梯度参数
tensor_y.backward(gradients) # 对矢量进行梯度计算需要指定梯度，tensor_x[0,0]与tensor_y[0,0]对应梯度0.1...
print(tensor_x.grad)
'''
tensor([[102.40, 1024.0, 0.10240]])
'''
(4) 不进行梯度计算
# 创建一个随机张量
tensor_x = torch.randn((1,3), requires_grad=True)
print(tensor_x.requires_grad)
'''
True
'''
# 进行梯度计算
tensor_y = tensor_x ** 2
print(tensor_y.requires_grad)
'''
True
'''
# 将变量包裹在no_grad()中，可以不进行梯度计算
with torch.no_grad():
tensor_y = tensor_x ** 2
print(tensor_y.requires_grad)
'''
False
'''
(5) 切断梯度计算
# 创建一个随机张量
tensor_x = torch.randn(3, requires_grad=True)
tensor_y = tensor_x ** 2
print(tensor_x.requires_grad)
print(tensor_y.requires_grad)
'''
True
True
'''
# 切断tensor_y的梯度计算
tensor_y = tensor_y.detach()
print(tensor_y.requires_grad)
'''
False
'''
3. 神经网络要素
3.1. 构建网络
(1) 使用torch.nn模块构建神经网络
关于torch.nn模块包含的全部方法在官方文档 torch.nn 中有详细介绍。翻译版可以在 PyTorch中的torch.nn模块使用详解 中查看
import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
#定义Net的初始化函数，这个函数定义了该神经网络的基本结构
def __init__(self):
super(Net, self).__init__() #复制并使用Net的父类的初始化方法，即先运行nn.Module的初始化函数
self.conv1 = nn.Conv2d(3, 6, 5) # 定义二维卷积层：输入为3通道图像,输出6个特征图, 卷积核为5x5正方形
self.conv2 = nn.Conv2d(6, 16, 5)# 定义二维卷积层：输入为6张特征图,输出16个特征图, 卷积核为5x5正方形
self.fc1 = nn.Linear(16*5*5, 120) # 定义线性全连接层：y = Wx + b，并将16*5*5个特征连接到120个节点上
self.fc2 = nn.Linear(120, 84)#定义线性全连接层：y = Wx + b，并将120个节点连接到84个节点上
self.fc3 = nn.Linear(84, 10)#定义线性全连接层：y = Wx + b，并将84个节点连接到10个节点上
#定义该神经网络的向前计算函数，该函数定义成功后，会自动生成反向传播函数（autograd）
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) #输入x经过卷积conv1之后，经过激活函数ReLU（原来这个词是激活函数的意思），使用2x2的窗口进行最大池化Max pooling，然后更新到x。
x = F.max_pool2d(F.relu(self.conv2(x)), 2) #输入x经过卷积conv2之后，经过激活函数ReLU，使用2x2的窗口进行最大池化Max pooling，然后更新到x。
x = x.view(-1, 16*5*5) #view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备，可验算这里的-1值为32。。
x = F.relu(self以上是关于从细节过渡到实例 一天学会Pytorch的主要内容，如果未能解决你的问题，请参考以下文章
啊哈~花一天快速上手Pytorch（可能是全网最全流程从0到部署）