p23损失函数与反向传播

loss function

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])

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

D:\anaconda\python.exe C:/Users/ASUS/Desktop/tudui/nn_los.py
tensor(0.6667)

Process finished with exit code 0

可设置L1Loss相关的计算方式

因为前面看的那个输入输出里面需要有batch_size，但是现在不需要必须输入batch_size这一参数了，所以不reshap也没问题

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])

loss = L1Loss(reduction='sum')
result = loss(inputs, targets)
print(result)

D:\anaconda\python.exe C:/Users/ASUS/Desktop/tudui/nn_los.py
tensor(2.)

Process finished with exit code 0

MSELoss

import torch
from torch.nn import L1Loss
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])

loss = L1Loss(reduction='sum')
result = loss(inputs, targets)
print(result)

lose_mse = nn.MSELoss()
result_mse = lose_mse(inputs, targets)
print(result_mse)

D:\anaconda\python.exe C:/Users/ASUS/Desktop/tudui/nn_los.py
tensor(2.)
tensor(1.3333)

Process finished with exit code 0

CrossEntropyLoss

It is useful when training a classification problem with C classes

import torch
from torch.nn import L1Loss
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])

loss = L1Loss(reduction='sum')
result = loss(inputs, targets)
print(result)

lose_mse = nn.MSELoss()
result_mse = lose_mse(inputs, targets)
print(result_mse)

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)

D:\anaconda\python.exe C:/Users/ASUS/Desktop/tudui/nn_los.py
tensor(2.)
tensor(1.3333)
tensor(1.1019)

Process finished with exit code 0

示例loss_network

发现CIFAR10的数据结构类似上面所举例

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

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=1)

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

    def forward(self, x):
        x = self.model1(x)
        return x
lixinyu = Lixinyu()
for data in dataloader:
    imgs, targets = data
    outputs = lixinyu(imgs)
    print(outputs)
    print(targets)

tensor([[-0.0434,  0.0130, -0.1247, -0.0355, -0.0632, -0.0156,  0.0355,  0.0226,
          0.0443,  0.1039]], grad_fn=<AddmmBackward0>)
tensor([4])

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

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=1)

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

    def forward(self, x):
        x = self.model1(x)
        return x
loss = nn.CrossEntropyLoss()
lixinyu = Lixinyu()
for data in dataloader:
    imgs, targets = data
    outputs = lixinyu(imgs)
    result_loss = loss(outputs, targets)
    print(result_loss)

tensor(2.3227, grad_fn=<NllLossBackward0>)
tensor(2.3795, grad_fn=<NllLossBackward0>)
tensor(2.4423, grad_fn=<NllLossBackward0>)
tensor(2.2870, grad_fn=<NllLossBackward0>)

backward

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

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=1)

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

    def forward(self, x):
        x = self.model1(x)
        return x
loss = nn.CrossEntropyLoss()
lixinyu = Lixinyu()
for data in dataloader:
    imgs, targets = data
    outputs = lixinyu(imgs)
    result_loss = loss(outputs, targets)
    result_loss.backward()
    print("ok")

运行完backward（）后，grad出现数值，必须有loss.backward（）,否则不会产生grad。
之后可通过相关优化器对其进行优化