Pytorch深度学习-损失函数和反向传播（小土堆）

• 计算实际输出与目标之间的差距
• 为我们更新输出提供一定的依据（反向传播）
• Loss越小越好
• 使用backword()可以获得梯度用以优化

L1Loss

1. API

torch.nn.functional.l1_loss（input， target， size_average=None， reduce=None， reduction='mean'） → tensor

2. 参数

1. size_average （bool， 可选） – 已弃用 （请参阅 `reduction` ）。默认情况下，损失是批处理中每个损失元素的平均值。请注意，对于某些损失，每个样品有多个元素。如果该字段 `size_average` 设置为 `False` ，则对每个小批量的损失求和。忽当 `reduce` 是 `False`时忽略 .默认值： `True`
2. reduce （bool， 可选） – 已弃用（请参阅 `reduction` ）。默认情况下，损失值将根据每个 `size_average` 小批量的观测值进行平均或求和。当 为 `False` 时 `reduce` ，则返回每个批处理元素的损失并忽略 `size_average` 。默认值： `True`
3. reduction （str， 可选） – 指定要应用于输出的缩减： `'none'` | `'mean'` | `'sum'` 。 `'none'` ：不应用减少， `'mean'` ：输出的总和将除以输出中的元素数， `'sum'` ：输出将被相加。注意： `size_average` 并且 `reduce` 正在被弃用，同时，指定这两个参数中的任何一个都将覆盖 `reduction` 。默认值： `'mean'`

3. shape

输入： (∗) ，其中 ∗ 表示任意数量的维度
目标： (∗) ，与输入的形状相同。
输出：标量。如果 `reduction` 是 `'none'` ，则 (∗)(∗) ，与输入的形状相同。

4. 代码示例

import torch  
from torch.nn import L1Loss  
  
#在下面的计算之中需要浮点数类型  
inputs =torch.tensor([1,2,3],dtype=torch.float32)  
targets = torch.tensor([1,2,5],dtype=torch.float32)  
#进行形状的旋转  
inputs = torch.reshape(inputs,(1,1,1,3))  
targets = torch.reshape(targets,(1,1,1,3))  
#实例化损失函数  
l1loss = L1Loss()  
  
result = l1loss(inputs,targets)  
  
print(result)

MSELoss

• API

torch.nn.functional.mse_loss(input, target, size_average=None, reduce=None, reduction='mean') → [Tensor]

• 参数

1. size_average （bool， 可选） – 已弃用 （请参阅 `reduction` ）。默认情况下，损失是批处理中每个损失元素的平均值。请注意，对于某些损失，每个样品有多个元素。如果该字段 `size_average` 设置为 `False` ，则对每个小批量的损失求和。当 `reduce` 是 `False`时忽略 .默认值： `True`
2. reduce （bool， 可选） – 已弃用（请参阅 `reduction` ）。默认情况下，损失值将根据每个 `size_average` 小批量的观测值进行平均或求和。当 为 `False` 时 `reduce` ，则返回每个批处理元素的损失并忽略 `size_average` 。默认值： `True`
3. reduction （str， 可选） – 指定要应用于输出的缩减： `'none'` | `'mean'` | `'sum'` 。 `'none'` ：不应用减少， `'mean'` ：输出的总和将除以输出中的元素数， `'sum'` ：输出将被相加。注意： `size_average` 并且 `reduce` 正在被弃用，同时，指定这两个参数中的任何一个都将覆盖 `reduction` 。默认值： `'mean'`

• 形状

输入： (∗) ，其中 ∗ 表示任意数量的维度。
目标： (∗) ，与输入的形状相同。

• 代码示例

import torch  
from torch import nn  
  
#在下面的计算之中需要浮点数类型  
inputs =torch.tensor([1,2,3],dtype=torch.float32)  
targets = torch.tensor([1,2,5],dtype=torch.float32)  
#进行形状的旋转  
inputs = torch.reshape(inputs,(1,1,1,3))  
targets = torch.reshape(targets,(1,1,1,3))  
#实例化损失函数  
mseloss = nn.MSELoss()  
  
result_mse = mseloss(inputs,targets)  
  
print(result_mse)

Cross Entropy

• API

torch.nn.functional.cross_entropy(input, target, weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean', label_smoothing=0.0)

• 参数（C表示一个类别）

1. input （Tensor） - 预测的非规范化对数;有关支持的形状，请参阅下面的“形状”部分。
2. target （Tensor） - 真实类指数或类概率;有关支持的形状，请参阅下面的“形状”部分。
3. weight（Tensor，可选）——为每个类手动调整权重。如果给定，则必须是大小为 C 的张量
4. size_average （bool， 可选） – 已弃用 （请参阅 `reduction` ）。默认情况下，损失是批处理中每个损失元素的平均值。请注意，对于某些损失，每个样本有多个元素。如果该字段 `size_average` 设置为 `False` ，则对每个小批量的损失求和。当 reduce 为 `False` 时忽略。违约： `True`
5. ignore_index （int， 可选） – 指定被忽略且对输入梯度没有贡献的目标值。当 `size_average` 时， `True` 损失在未被忽略的目标上取平均值。请注意，仅当目标包含类索引时才 `ignore_index` 适用。默认值：-100
6. reduce （bool， 可选） – 已弃用（请参阅 `reduction` ）。默认情况下，损失值将根据每个 `size_average` 小批量的观测值进行平均或求和。当 为 `False` 时 `reduce` ，则返回每个批处理元素的损失并忽略 `size_average` 。默认值： `True`
7. reduction （str， 可选） – 指定要应用于输出的缩减： `'none'` | `'mean'` | `'sum'` 。 `'none'` ：不应用减少， `'mean'` ：输出的总和将除以输出中的元素数， `'sum'` ：输出将被相加。注意： `size_average` 并且 `reduce` 正在被弃用，同时，指定这两个参数中的任何一个都将覆盖 `reduction` 。默认值： `'mean'`
8. label_smoothing （float， 可选） - [0.0， 1.0] 中的浮点数。指定计算损耗时的平滑量，其中 0.0 表示无平滑。这些目标成为原始真实值和均匀分布的混合体，如重新思考计算机视觉的初始架构中所述。默认值： 0.00.0 .

• 形状

输入：形状 (𝐶) ， (𝑁,𝐶) 或 (𝑁,𝐶,𝑑1,𝑑2,...,𝑑𝐾) 在 K 维损失的情况下使用 𝐾≥1 。
目标：如果包含类索引、形状 ()， (𝑁)或者 (𝑁,𝑑1,𝑑2,...,𝑑𝐾) 在 K 维损失的情况下， 𝐾≥1 每个值应介于 [0,𝐶) .如果包含类概率，则与输入的形状相同，并且每个值应介于 [0,1] 之间。

• 代码示例

import torch  
from torch import nn  
from torch.nn import CrossEntropyLoss  
  
x = torch.tensor([0.1,0.2,0.3])  
y = torch.tensor([1])  
x = torch.reshape(x,(1,3))  
loss_cross = CrossEntropyLoss()  
  
result = loss_cross(x,y)  
print(result)

一个示例

from torch import nn  
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear  
import torchvision  
from torch.utils.data import DataLoader  
  
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)  
  
dataloader = DataLoader(dataset=dataset,batch_size=64)  
class seq(nn.Module):  
    def __init__(self, *args, **kwargs) -> None:  
        super().__init__(*args, **kwargs)  
        #sequential使用  
        self.model1 = Sequential(  
            Conv2d(3,32,5,padding=2),  
            MaxPool2d(2),  
            Conv2d(32,32,5,stride=1,padding=2),  
            MaxPool2d(2),  
            Conv2d(32,64,5,stride=1,padding=2),  
            MaxPool2d(2),  
            Flatten(),  
            Linear(64*4*4,64),  
            Linear(64,10),  
        )  
    def forward(self,x):  
        x = self.model1(x)  
        return x  
loss = nn.CrossEntropyLoss()  
seq_test = seq()  
for data in dataloader:  
    imgs,targets = data  
    outputs = seq_test(imgs)  
    results = loss(outputs,targets)  
    print(results)