sunpongber

损失函数与反向传播

PyTorch官网

Loss Functions
计算实际输出和目标之间的差距
为我们更新输出提供一定的依据（反向传播）
越小越好

L1Loss

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)

# RuntimeError: mean(): could not infer output dtype. Input dtype must be either a floating point or complex dtype. Got: Long
# 运行时错误：mean（）：无法推断输出数据类型。输入数据类型必须是浮点型或复数型。实际为：Long
# dtype=torch.float32

inputs = torch.reshape(inputs, (1, 1, 1, 3)) # 1 batchsize 1channel 1行 3列
targets = torch.reshape(targets, (1, 1, 1, 3))

loss = L1Loss()
result = loss(inputs, targets)

print(result)

loss = L1Loss(reduction='sum')返回tensor(2.)

MSELoss

loss_mse = MSELoss()
result_mse = loss_mse(inputs, targets)
print(result_mse)

返回：tensor(1.3333)

CrossEntropyLoss

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

返回：tensor(1.1019)

计算实际输出和目标输出之间的差距

import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10(root="P19_nn_maxpool/dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)

dataLoader = DataLoader(dataset, batch_size=1)

class nn_squential(nn.Module):
    def __init__(self):
        super(nn_squential, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)

        return x

loss = nn.CrossEntropyLoss()

NN_squential = nn_squential()

for data in dataLoader:
    imgs, targets = data
    outputs = NN_squential(imgs)
    # print(outputs)
    # print(targets)
    result_loss = loss(outputs, targets)
    print(result_loss)

返回：

tensor(2.3093, grad_fn=<NllLossBackward0>)
...

为我们更新输出提供一定的依据（反向传播）
如何提供的呢？给我们当中的每一个需要调优的参数，对神经网络来说，或者对卷积层来说，其中的每一个卷积核就是需要调优的
它给每一个卷积层中的参数设置了一个grad（梯度），当我们去采用反向传播的时候每一个节点或者说每一个要分析的参数，它都会求出来一个对应的梯度
然后在优化的过程中，就可以根据这个梯度对当中的参数进行一个优化，最终达到整个loss降低的目的

梯度下降法

result_loss.backward()，用backward让它自己去做一个反向传播，它就可以计算出每一个节点的参数
有了各个节点参数的梯度，接下来选择合适的优化器，来对这些参数进行一个优化，使整个loss达到降低的一个目的

原始资料地址：
损失函数与反向传播
如有侵权联系删除 仅供学习交流使用