目录
1. Pytorch 学习
今天主要学习Pytorch的Loss Functions、反向传播、优化器optim和一个完整的神经网络的例子等的内容【PS：注意结合前边内容。】
Pytorch 学习第【1】天
Pytorch 学习第【2】天
Pytorch 学习第【3】天
Pytorch 学习第【4】天
Pytorch 学习第【5】天
Pytorch 学习第【6】天
2.损失函数 Loss Functions
2.1 torch.nn.L1Loss
创建一个标准，测量输入x和目标y中每个元素之间的平均绝对误差（MAE）。
参数：
torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')
解析：
size_average (bool, optional) - 弃用（见减少）。默认情况下，损失是对批次中的每个损失元素进行平均的。注意，对于某些损失，每个样本有多个元素。如果字段size_average被设置为False，则损失是对每个minibatch进行求和。当reduce为False时被忽略。默认值。真
reduce (bool, optional) - 弃用（见reduction）。默认情况下，根据size_average对每个minibatch的观测值进行平均或求和。当reduce为False时，返回每批元素的损失，而忽略size_average。默认情况下。真‘
reduction (string, optional) - 指定要应用于输出的缩减。‘none’ | ‘mean’ | ‘sum’。‘none’：不应用任何减少，‘mean’：输出的总和将除以输出中的元素数，‘sum’：输出将被加总。注意：size_average和reduce正在被废
形状：
输入：()，其中∗表示任何数量的尺寸。
目标：(*)，与输入的形状相同。
输出：标量。如果减少是 “无”，则(*)，与输入相同的形状。
计算公式：
图例：
【PS：这里相减是包含绝对值。】
2.1.1 python代码例子
2.1.1.1 上边的例子复现代码
import torch
from torch import nn
loss = nn.L1Loss(reduction='sum')
input = torch.arange(1, 26, dtype=torch.float).reshape(5, 5)
target = torch.arange(1, 26, dtype=torch.float).reshape(5, 5)
output = loss(input, target)
print(input)
print(target)
print(output)
输出结果：
tensor([[ 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10.],
[11., 12., 13., 14., 15.],
[16., 17., 18., 19., 20.],
[21., 22., 23., 24., 25.]])
tensor([[ 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10.],
[11., 12., 13., 14., 15.],
[16., 17., 18., 19., 20.],
[21., 22., 23., 24., 25.]])
tensor(0.)
2.2 torch.nn.MSELoss
创建一个标准，测量输入x和目标y中每个元素之间的平均平方误差（平方L2准则）。
参数：
torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')
解析：
size_average (bool, optional) - 弃用（见减少）。默认情况下，损失是对批次中的每个损失元素进行平均的。注意，对于某些损失，每个样本有多个元素。如果字段size_average被设置为False，则损失是对每个minibatch进行求和。当reduce为False时被忽略。默认值。真
reduce (bool, optional) - 弃用（见reduction）。默认情况下，根据size_average对每个minibatch的观测值进行平均或求和。当reduce为False时，返回每批元素的损失，而忽略size_average。默认情况下。真
reduction (string, optional) - 指定要应用于输出的缩减。‘none’ | ‘mean’ | ‘sum’。‘none’：不应用任何减少，‘mean’：输出的总和将除以输出中的元素数，‘sum’：输出将被加总。注意：size_average和reduce正在被废弃，在此期间，指定这两个args中的任何一个都会覆盖reduction。默认值：‘平均’。
形状：
输入：(∗)，其中*∗表示任何数目的维度。
目标：（∗），与输入的形状相同。
计算公式：
图例：
2.2.1 python代码例子
2.2.1.1 上边的例子复现代码
import torch
from torch import nn
loss = nn.MSELoss(reduction='sum')
# loss = nn.MSELoss()
input = torch.arange(1, 26, dtype=torch.float).reshape(5, 5)
target = torch.arange(3, 28, dtype=torch.float).reshape(5, 5)
output = loss(input, target)
print(input)
print(target)
print(output)
输出结果：
tensor([[ 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10.],
[11., 12., 13., 14., 15.],
[16., 17., 18., 19., 20.],
[21., 22., 23., 24., 25.]])
tensor([[ 3., 4., 5., 6., 7.],
[ 8., 9., 10., 11., 12.],
[13., 14., 15., 16., 17.],
[18., 19., 20., 21., 22.],
[23., 24., 25., 26., 27.]])
tensor(100.)
2.3 torch.nn.CrossEntropyLoss
这个标准计算了输入和目标之间的交叉熵损失。
【PS：这里扩展介绍下信息熵，交叉熵和相对熵】
2.3.1 信息熵，交叉熵和相对熵
（1）信息熵：
信息熵是由信息论之父香农提出来的，它用于随机变量的不确定性度量，先上信息熵的公式。
举个例子：
想要买台电脑。但是不确定要买什么牌子。以下有两种情况：
情况一：
| 序列 | 事件 | 概率 | 信息量 C |
|---|---|---|---|
| A | 戴尔 | 0.25 | -log(p(A)) = 1.38629436112 |
| B | 联想 | 0.25 | -log(p(B)) = 1.38629436112 |
| C | 华硕 | 0.25 | -log(p©) = 1.38629436112 |
| D | 苹果 | 0.25 | -log(p(D)) = 1.38629436112 |
此时你的大脑混杂程度：（信息熵）
-[ p(A)*log(p(A)) + p(B)*log(p(B)) + p©*log(p©) + p(D)*log(p(D)) ] =1.38629436112
情况二：
| 序列 | 事件 | 概率 | 信息量 C |
|---|---|---|---|
| A | 戴尔 | 0.1 | -log(p(A))=2.302585092994 |
| B | 联想 | 0.2 | -log(p(B))=1.609437912434 |
| C | 华硕 | 0.1 | -log(p©)=2.302585092994 |
| D | 苹果 | 0.6 | -log(p(D))=0.510825623766 |
此时你的大脑混杂程度：（信息熵）
-[ p(A)*log(p(A)) + p(B)*log(p(B)) + p©*log(p©) + p(D)*log(p(D)) ] =1.088899975345
【PS：信息熵是信息论中用于度量信息量的一个概念。一个系统越是有序，信息熵就越低；反之，一个系统越是混乱，信息熵就越高】
（2）交叉熵：
这里可以引申出交叉熵的理解，现在有两个分布，真实分布p和非真实分布q，我们的样本来自真实分布p.
（1）按照真实分布p来编码样本所需的编码长度的期望为
这就是上面说的信息熵H( p )
（2）按照不真实分布q来编码样本所需的编码长度的期望为
这就是所谓的交叉熵H( p,q )
（3）这里引申出KL散度D(p||q) = H(p,q) - H( p) =
也叫做相对熵，它表示两个分布的差异，差异越大，相对熵越大。
对于还是不太懂的可以参考：
2.3.2 参数解析
参数：
torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=- 100, reduce=None, reduction='mean', label_smoothing=0.0)
解析：
weight (Tensor, optional) - 给予每个类别的手动重新缩放权重。如果给定，必须是一个大小为C的张量。
size_average (bool, optional) - 弃用（见减少）。默认情况下，损失是对批次中的每个损失元素进行平均的。注意，对于某些损失，每个样本有多个元素。如果字段size_average被设置为False，则损失是对每个minibatch进行求和。当reduce为False时被忽略。默认值。真
ignore_index (int, optional) - 指定一个被忽略的目标值，不对输入梯度产生影响。当size_average为True时，损失是对非忽略的目标值进行平均的。注意，ignore_index只在目标值包含类指数时适用。
reduce (bool, optional) - 弃用（见reduction）。默认情况下，根据size_average对每个minibatch的观测值进行平均或求和。当reduce为False时，返回每批元素的损失，而忽略size_average。默认情况下。真
reduction (string, optional) - 指定要应用于输出的缩减。‘none’ | ‘mean’ | ‘sum’。‘none’：不应用减法，‘mean’：取输出的加权平均值，‘sum’：输出将被求和。注意：size_average和reduce正在被废弃，在此期间，指定这两个参数中的任何一个都会覆盖reduction。默认值：‘平均’。
label_smoothing (float, optional) - 一个在[0.0, 1.0]中的浮点数。指定计算损失时的平滑量，其中0.0意味着没有平滑。目标成为原始地面真实和均匀分布的混合物，如《重新思考计算机视觉的初始架构》中所述。默认值：0.00.0。
形状:
【PS：到这里有看不懂了。其实问题不大这可能对交叉熵不太清楚。后边举个例子计算下，应该能更好的理解。】
2.3.3 python代码例子
2.3.3.1 上边的例子复现代码
import torch
from torch import nn
x =torch.tensor([0.1,0.2,0.4]).reshape((1,3))
y =torch.tensor([1])
loss_cross=nn.CrossEntropyLoss()
result = loss_cross(x,y)
print(result)
输出结果：
tensor(1.1398)
进程已结束,退出代码0
3. 反向传播
前向传播通过训练数据和权重参数计算输出结果；反向传播通过导数链式法则计算损失函数对各参数的梯度，并根据梯度进行参数的更新，这一点是重点，会在后文详叙。可以参考
【PS：简单来说我们再使用损失函数的时候，我们可以调用反向传播。反向传播就可求出需要调节参数，或者参数对应的梯度。然后有了梯度我们就可以通过优化器对参数进行调整。从而达到我整体误差降低的目的。】
4. 优化器torch.optim
torch.optim是一个实现各种优化算法的包。大多数常用的方法已经被支持，而且接口足够通用，所以将来也可以很容易地集成更复杂的方法。
如何使用优化器：
为了使用torch.opt，你必须构造一个优化器对象，它将保持当前状态并根据计算的梯度更新参数。
（1）构建一个优化器
例如：
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)
【PS：是什么优化器这里也不需要知道。知道构建一个优化器并不难。】
（2）参数的选项
优化器也支持指定每个参数的选项。要做到这一点，与其传递Variable s的迭代，不如传递dict s的迭代。每一个迭代都将定义一个单独的参数组，并且应该包含一个params键，包含属于它的参数列表。其他键应该与优化器接受的关键字参数相匹配，并将被用作该组的优化选项。
注意：
你仍然可以把选项作为关键字参数传递。它们将被用作默认值，在没有覆盖它们的组中使用。当你只想改变一个选项，而在参数组之间保持所有其他选项的一致性时，这很有用。
例如：
指定每层的学习率时。
optim.SGD([
{'params': model.base.parameters()},
{'params': model.classifier.parameters(), 'lr': 1e-3}
], lr=1e-2, momentum=0.9)
这意味着model.base的参数将使用默认的1e-2的学习率，model.classifier的参数将使用1e-3的学习率，而所有参数将使用0.9的动量。
（3）采取优化步骤
所有的优化器都实现了一个step()方法，用来更新参数。它可以以两种方式使用。
1、optimizer.step()
这是大多数优化器所支持的简化版本。一旦梯度被计算出来，就可以使用例如backward()来调用这个函数。
例子：
for input, target in dataset:
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
2、optimizer.step(closure)
一些优化算法，如共轭梯度和LBFGS需要多次重新评估函数，所以你必须传入一个闭包，让他们重新计算你的模型。这个闭包应该清除梯度，计算损失，并返回它。
例如：
for input, target in dataset:
def closure():
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
return loss
optimizer.step(closure)
【PS：以上来自官方文档的解释】
5. 完整模型例子
例子是CIFAR的分类，模型如下：
(1)model.py代码：
# 准备数据集：
import torch
from torch import nn
# 搭建神经网络
class example(nn.Module):
def __init__(self):
super(example, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self, x):
x = self.model(x)
return x
# 测试
if __name__ == '__main__':
jiuchong = example()
input = torch.ones((64,3,32,32))
output = jiuchong(input)
print(output.shape)
(2) main.py代码：
import torch.cuda
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *
# 准备数据集合
device =torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_data = torchvision.datasets.CIFAR10(root='./dataset', train=True, transform=torchvision.transforms.ToTensor(),
download=True)
test_data = torchvision.datasets.CIFAR10(root='./dataset', train=False, transform=torchvision.transforms.ToTensor(),
download=True)
# 保存训练集和测试集的长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# print("训练数据集的长度为：{}".format(train_data_size))
# print("测试数据集的长度为：{}".format(test_data_size))
# 加载数据集
train_dataloader = DataLoader(dataset=train_data, batch_size=64)
test_dataloader = DataLoader(dataset=test_data, batch_size=64)
#模型实例化
jiuchong = example()
jiuchong = jiuchong.to(device)
#损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn=loss_fn.to(device)
#优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(jiuchong.parameters(),lr = learning_rate)
# 设置训练网络的一些参数
total_train_step = 0
total_test_step = 0
epoch = 20
# tensorboard的运用
writer = SummaryWriter("./logs_train")
for i in range(epoch):
print("-------第{}轮训练开始------".format(i+1))
jiuchong.train()
for data in train_dataloader:
imgs ,targets =data
imgs = imgs.to(device) #使用GPU
targets =targets.to(device) #使用GPU
outputs =jiuchong(imgs)
loss = loss_fn(outputs,targets)
# 优化器优化模型
optimizer.zero_grad() # 梯度设置为0
loss.backward() # 反向传播
optimizer.step() # 采取优化步骤
total_train_step +=1
# tensorboard train_loss 画图
if total_train_step % 100 == 0:
print("训练次数：{}，loss：{}".format(total_train_step,loss.item()))
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 训练集
total_test_loss = 0
total_accuracy = 0
jiuchong.eval()
with torch.no_grad(): #这里只是测试，不在梯度下降
for data in test_dataloader:
imgs, targets = data
imgs = imgs.to(device)
targets =targets.to(device)
outputs = jiuchong(imgs)
loss = loss_fn(outputs,targets)
total_test_loss += loss
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print("整体测试集熵的Loss：{}".format(total_test_loss))
print("整体的测试集的正确率：{}".format(total_accuracy/test_data_size))
# tensorboard test_loss 、test_accuracy画图
writer.add_scalar("test_loss",total_test_loss,total_test_step)
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step +=1
# 保存模型
# torch.save(jiuchong,"tudui_{}.pth".format(i))
writer.close()
输出结果：
-------第20轮训练开始------
训练次数：14900，loss：0.5706865787506104
训练次数：15000，loss：0.8623301982879639
训练次数：15100，loss：0.7635148763656616
训练次数：15200，loss：0.9178880453109741
训练次数：15300，loss：0.7020710706710815
训练次数：15400，loss：0.9142396450042725
训练次数：15500，loss：0.9747730493545532
训练次数：15600，loss：0.8371116518974304
整体测试集熵的Loss：166.2091064453125
整体的测试集的正确率：0.6432999968528748
进程已结束,退出代码0
tensorboard:
本文作者：九重！
本文链接：https://blog.csdn.net/weixin_43798572/article/details/124667600
关于博主：评论和私信会在第一时间回复。或者直接私信我。
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【点赞】【收藏】一下。您的鼓励是博主的最大动力！
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
