从细节过渡到实例 一天学会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
'''

# 张量的数据类型总结:
# 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的互相转换

(1) Tensor 转 Numpy

# 创建一个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.]]
'''

(2) Numpy 转 Tensor

# 创建一个1数组
array_ones = numpy.ones(5)
'''
[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.float64)
'''

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.fc1(x)) #输入x经过全连接1,再经过ReLU激活函数处理,然后更新x
        x = F.relu(self.fc2(x)) #输入x经过全连接2,再经过ReLU激活函数处理,然后更新x
        x = self.fc3(x) #输入x经过全连接3处理,然后更新x
        return x

(2) 查看神经网络的参数

# 实例化一个神经网络
net = Net()
layers = list(net.parameters())

# 查看神经网络的基本结构信息
print(net)
'''
Net(
  (conv1): Conv2d(3, 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)
)
'''

# 查看神经网络的总层数
print(len(layers)) 
'''
10
'''

# 查看最后一层的参数
print(layers[-1]) 
'''
Parameter containing:
tensor([-0.0674,  0.0600,  0.0800, -0.0760,  0.0293,  0.0745,  0.0182,  0.0616,
        -0.0197,  0.0729], requires_grad=True)
'''

# 查看第一层的大小
print(layers[0].size()) 
'''
torch.Size([6, 3, 5, 5])
'''

# 查看每一层的参数和节点数量
total_parameter=0
layer_num = 1
for layer in layers:
    parameter = 1
    for _ in layer.size():
        parameter *= _
    print("第" + str(layer_num) + "层的结构:"+ str(list(layer.size())) + ",参数和:"+ str(parameter))
    total_parameter = total_parameter + parameter
    layer_num += 1
print("总参数和:"+ str(total_parameter))
'''
第1层的结构:[6, 3, 5, 5],参数和:450
第2层的结构:[6],参数和:6
第3层的结构:[16, 6, 5, 5],参数和:2400
第4层的结构:[16],参数和:16
第5层的结构:[120, 400],参数和:48000
第6层的结构:[120],参数和:120
第7层的结构:[84, 120],参数和:10080
第8层的结构:[84],参数和:84
第9层的结构:[10, 84],参数和:840
第10层的结构:[10],参数和:10
总参数和:62006

Process finished with exit code 0

'''

(3) 查看前向计算过程

# 实例化一个神经网络
net = Net()
input = torch.randn(2, 3, 32, 32) # 产生2个3通道,32*32的随机输入,这是nn.Conv2d的接收格式
out = net(input)
print(out)
'''
tensor([[-0.1063,  0.0641, -0.0391, -0.0517,  0.1174, -0.0600,  0.0044, -0.0311,
         -0.1074,  0.0226],
        [-0.0779,  0.0697, -0.0486, -0.0842,  0.1377, -0.0276, -0.0247, -0.0504,
         -0.1054,  0.0065]], grad_fn=<AddmmBackward>)
'''

(4) 查看反向传播过程

net = Net() # 实例化一个神经网络
net.zero_grad() # 梯度初始化

input = torch.randn(1, 3, 32, 32) 
out = net(input)

out.backward(torch.randn(1, 10)) # 随机选取参数进行反向传播
print(out)

'''
tensor([[-0.0829,  0.0556, -0.0088, -0.0263, -0.0518,  0.0802, -0.0923,  0.0091,
          0.0122,  0.0927]], grad_fn=<AddmmBackward>)
'''

3.2. 损失函数

(1) 定义损失函数并计算损失

net = Net()
criterion = nn.MSELoss() # 定义均方误差损失函数
target = torch.randn(10).view(1, -1)  # 定义10个随机真值(因为网络最后一层有10个输出),并转换为行向量
print(target)
'''
tensor([[-1.1115, -0.3807,  0.5877, -1.0567, -0.0541, -0.3390, -1.9487, -0.2775,
         -0.0366,  0.7521]])
'''

output = net(torch.randn(1, 3, 32, 32))  # 用随机输入计算输出
loss = criterion(output, target)  # 计算损失
print(output)
print(loss)

'''
tensor([[ 0.0881, -0.0362, -0.1039, -0.0116,  0.0952,  0.0953, -0.0499,  0.0214,
         -0.0549, -0.0493]], grad_fn=<AddmmBackward>)
tensor(0.7676, grad_fn=<MseLossBackward>)
'''

PyTorch的损失函数有十九种,可以在官方文档 PyTorch Loss-Functions 中查看,中文译版可以在博客 Pytorch学习之十九种损失函数 中查看,常用的损失函数如下:

描述损失函数
L1损失L1Loss
平滑L1损失SmoothL1Loss
均方误差损失MSELoss
交叉熵损失CrossEntropyLoss
KL散度损失KLDivLoss
余弦损失CosineEmbeddingLoss
二分类逻辑损失SoftMarginLoss
负对数似然损失NLLLoss
二维负对数似然损失NLLLoss2d
泊松负对数似然损失PoissonNLLLoss

(2) 计算损失的反向传播

net = Net()
net.zero_grad() # 梯度初始化
criterion = nn.MSELoss() # 定义均方误差损失函数

target = torch.randn(10).view(1, -1)  # 定义10个随机真值(因为网络最后一层有10个输出),并转换为行向量
output = net(torch.randn(1, 3, 32, 32))  # 用随机输入计算输出

loss = criterion(output, target)  # 计算损失
loss.backward() # 损失反向传播
print('conv1.bias.grad before backward: ' + str(net.conv1.bias.grad))
print('conv2.bias.grad before backward: ' + str(net.conv2.bias.grad))
print('fc3.bias.grad before backward: ' + str(net.fc3.bias.grad))

'''
conv1.bias.grad before backward: tensor([ 0.0213, -0.0110,  0.0120, -0.0252, -0.0081,  0.0115])
conv2.bias.grad before backward: tensor([ 0.0169,  0.0230,  0.0039, -0.0125,  0.0182,  0.0000, -0.0253,  0.0000, -0.0133, -0.0038,  0.0196, -0.0379, -0.0142, -0.0147, -0.0534,  0.0265])
fc3.bias.grad before backward: tensor([ 0.2603, -0.1132,  0.0708,  0.1399, -0.2388,  0.1579, -0.0635,  0.0143, -0.5937,  0.1236])
'''

3.3. 优化器

优化器用于管理并更新模型中可学习参数(权值、偏置bias)的值。

(1) 定义优化器算法,并使用优化器更新权重

net = Net()
net.zero_grad() # 梯度初始化
criterion = nn.MSELoss() # 定义均方误差损失函数
optimizer = optim.SGD(net.parameters(), lr=0.01) # 定义随机梯度下降优化算法,并设置学习率为0.01
optimizer.zero_grad() # 优化器梯度初始化

target = torch.randn(10).view(1, -1)  # 定义10个随机真值(因为网络最后一层有10个输出),并转换为行向量
output = net(torch.randn(1, 3, 32, 32))  # 用随机输入计算输出

loss = criterion(output, target)  # 计算损失
loss.backward() # 损失反向传播
optimizer.step() # 对网络模型参数进行优化
print('conv1.bias.grad before backward: ' + str(net.conv1.bias.grad))
print('conv2.bias.grad before backward: ' + str(net.conv2.bias.grad))
print('fc3.bias.grad before backward: ' + str(net.fc3.bias.grad))
print(loss)
'''
conv1.bias.grad before backward: tensor([ 0.0046,  0.0145, -0.0112, -0.0003,  0.0035,  0.0078])
conv2.bias.grad before backward: tensor([-0.0040, -0.0106,  0.0092,  0.0102,  0.0140, -0.0078, -0.0187, -0.0118,
        -0.0066, -0.0005, -0.0054,  0.0032,  0.0016,  0.0033, -0.0020, -0.0043])
fc3.bias.grad before backward: tensor([ 0.0078, -0.0456,  0.0653, -0.0499,  0.2710, -0.1554,  0.0496, -0.2634,
        -0.0601,  0.0723])
tensor(0.4679, grad_fn=<MseLossBackward>)
'''

PyTorch的各类优化器可以在官方文档 PyTorch TORCH.OPTIM 中查看,中文译版可以在博客 Pytorch的优化器总结 中查看,常用的优化器如下:

描述优化器
随机梯度下降算法SGD
标准动量优化算法Momentum
均方根比例算法RMSProp
自适应矩估计算法Adam

3.4. 模型存取

(1) 保存训练好的模型

# 实例化一个神经网络
net = Net()

# 方法一,保存整个网络
torch.save(net, './my_net.pth')

# 方法二,保存网络的状态信息
torch.save(net.state_dict(), './my_net.pth')

(2) 读取保存的模型

# 提取整个网络
pretrained_net = torch.load('./my_net.pth')

# 提取网络状态
net_new = Net()
net_new.load_state_dict(torch.load('./my_net.pth'))

4. 神经网络实例

4.1. 分类神经网络

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

# 构造数据
n_data = torch.ones(100, 2)
x0 = torch.normal(3*n_data, 1)
x1 = torch.normal(-3*n_data, 1)
# 标记为y0=0,y1=1两类标签
y0 = torch.zeros(100)
y1 = torch.ones(100)

# 通过.cat连接数据
x = torch.cat((x0, x1), 0).type(torch.float)
y = torch.cat((y0, y1), 0).type(torch.long)

# 构造一个简单的神经网络
class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.inLayer = torch.nn.Linear(n_feature, n_hidden) # 输入层
        self.hiddenLayer = torch.nn.Linear(n_hidden, n_hidden) # 隐藏层
        self.outLayer = torch.nn.Linear(n_hidden, n_output) # 输出层

    # 前向计算函数,定义完成后会隐式地自动生成反向传播函数
    def forward(self, x):
        x = F.relu(self.hiddenLayer(self.inLayer(x)))
        x = self.outLayer(x)
        return x

net = Net(2, 10, 2) # 初始化一个网络,2个输入层节点,10个隐藏层节点,2个输出层节点
loss_func = torch.nn.CrossEntropyLoss() # 定义交叉熵损失函数
optimizer = torch.optim.SGD(net.parameters(), lr=0.2) # 配置网络优化器

# 将网络模型、损失函数和输入张量迁入GPU
if(torch.cuda.is_available()):
    net = net.cuda()
    loss_func = loss_func.cuda()
    x, y = x.cuda(), y.cuda()

# 训练模型
out = net(x)
for t in range(300):
    out = net(x) # 将数据输入网络,得到输出
    loss = loss_func(out, y) # 得到损失
    optimizer.zero_grad() # 梯度初始化
    loss.backward() # 反向传播
    optimizer.step() # 对网络进行优化

# 使用模型进行预测
prediction = torch.max(F.softmax(out, dim=0), 1)[1]
pred_y = prediction.data.cpu().numpy().squeeze()

# 可视化
plt.scatter(x.data.cpu().numpy()[:, 0], x.data.cpu().numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlBu')
plt.show()

在这里插入图片描述

4.2. 回归神经网络

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

# 构造数据
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
y = x.pow(2) + 0.2 * torch.rand(x.size())

# 构造一个简单的神经网络
class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.inLayer = torch.nn.Linear(n_feature, n_hidden) # 输入层
        self.hiddenLayer = torch.nn.Linear(n_hidden, n_hidden) # 隐藏层
        self.outLayer = torch.nn.Linear(n_hidden, n_output) # 输出层

    # 前向计算函数,定义完成后会隐式地自动生成反向传播函数
    def forward(self, x):
        x = F.relu(self.hiddenLayer(self.inLayer(x)))
        x = self.outLayer(x)
        return x

net = Net(1, 10, 1) # 初始化一个网络,1个输入层节点,10个隐藏层节点,1个输出层节点
loss_func = torch.nn.MSELoss() # 定义均方误差损失函数
optimizer = torch.optim.SGD(net.parameters(), lr=0.2) # 配置网络优化器

# 将网络模型、损失函数和输入张量迁入GPU
if(torch.cuda.is_available()):
    net = net.cuda()
    loss_func = loss_func.cuda()
    x, y = x.cuda(), y.cuda()

# 训练模型
out = net(x)
for t in range(300):
    out = net(x) # 将数据输入网络,得到输出
    loss = loss_func(out, y) # 得到损失
    optimizer.zero_grad() # 梯度初始化
    loss.backward() # 反向传播
    optimizer.step() # 对网络进行优化

# 可视化
plt.scatter(x.data.cpu().numpy(), y.data.cpu().numpy())
plt.plot(x.data.cpu().numpy(), out.data.cpu().numpy(), 'r-', lw=5)
plt.show()

在这里插入图片描述

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 撸撸猫 设计师:C马雯娟 返回首页