Pytorch深度学习快速入门教程 -- 土堆教程笔记（二）

最新推荐文章于 2024-05-31 16:43:32 发布
最新推荐文章于 2024-05-31 16:43:32 发布
阅读量1k 收藏 26
点赞数 10
分类专栏： Pytorch深度学习入门 文章标签： 深度学习 pytorch python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43636084/article/details/125969411
版权

Pytorch入门学习（二）

神经网络基本骨架 - nn.Module

  • nn就是neural network的缩写
  • 自定义神经网络需要继承nn.Module
  • 重写__init__()和forward()
  • 调用，先实例神经网络类，再隐式输入（由于前面讲到forward方法的特殊性）
import torch
from torch import nn

# 自定义神经网络类，继承nn.Module，重写init和forward方法
class MyMdoule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
    def forward(self, input):
        output = input + 1
        return output

# 首先实例化
myModule = MyMdoule()
# 隐式输入(forward方法特殊性,等同于.forward(1.0))
output = myModule(1.0)
print(output) # 2.0
# 通常神经网络的输入为tensor类型
x = torch.tensor(1.0)
output = myModule(x)
print(output)  # tensor(2.)

卷积操作

  • torch.nn.functional.Conv2d(input, weight, bias, stride, padding)
  • 参数input的尺寸要求是(batch_size, channels, h, w)
  • 参数weight的尺寸要求是(batch_size, channels, h, w)
  • 参数bias是偏置，默认none
  • 参数stride是卷积核移动路径，默认为1
  • 参数padding是输入两边的填充，默认为0
import torch
import torch.nn.functional as F

# Conv2d(input, weight, bias, stride, padding)
# 参数input的尺寸要求是(batch_size, channels, h, w)
# 参数weight的尺寸要求是(batch_size, channels, h, w)
# 参数bias是偏置，默认none
# 参数stride是卷积核移动路径，默认为1
# 参数padding是输入两边的填充，默认为0

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]])
kernel = torch.tensor([[1, 2, 1],
                      [0, 1, 0],
                      [2, 1, 0]])
print(input.shape) # torch.Size([5, 5])
print(kernel.shape) # torch.Size([3, 3])

# reshape()参数Tensor为输入
# reshape()参数shape为目标shape，（batch_size, channels, h, w）
input = torch.reshape(input, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))
print(input.shape) # torch.Size([1, 1, 5, 5])
print(kernel.shape) # torch.Size([1, 1, 3, 3])

output = F.conv2d(input, kernel, stride=1)
print(output)
# tensor([[[[10, 12, 12],
#           [18, 16, 16],
#           [13,  9,  3]]]])

# 将参数stride改为2（默认为1）
output2 = F.conv2d(input, kernel, stride=2)
print(output2)
# tensor([[[[10, 12],
#           [13,  3]]]])

# 将参数padding改为1（默认为0）
output3 = F.conv2d(input, kernel, padding=1)
print(output3)
# tensor([[[[ 1,  3,  4, 10,  8],
#           [ 5, 10, 12, 12,  6],
#           [ 7, 18, 16, 16,  8],
#           [11, 13,  9,  3,  4],
#           [14, 13,  9,  7,  4]]]])
  • 示意图
    在这里插入图片描述

神经网络 - 卷积层

简单介绍

  • torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, padding_mode, dilation, groups, bias)
  • in_channels：int，输入图像的通道数
  • out_channels：int，输出图像的通道数
  • kernel_size：int or tuple，卷积核的尺寸
  • stride：int or tuple，卷积核的移动步径，默认1
  • padding：int , tuple or str，输入图像周围的填充，默认0
  • padding_mode：填充的模式，默认zeros
  • dilation：卷积核元素间的距离，默认为1，dilation为1就是卷积核元素间没有距离，这里容易造成误解。
  • bias：偏置，为True添加
  • 动态观察stride和padding参数的效果
  • 注意，我们只需要设定卷积核的尺寸大小，其具体的参数我们不需要去设定，因为神经网络在训练过程中会不断调整卷积核的参数，达到目标。
  • 当in_channels=1，卷积核的数目为2时，则out_channels=2，不同层叠加在一块进行输出。
    • 我们不需要去考虑卷积核的数目，只需要添加in_channels和out_channels的值。
      在这里插入图片描述
  • 代码
import torchvision
from torch import nn
from torch.utils.data import DataLoader

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

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        output = self.conv1(x)
        return output

myModule = MyModule()
print(myModule)
# MyModule(
#   (conv1): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
# )

for data in dataloader:
    # 获取数据包
    imgs, targets = data
    # 输入 -> 输出
    outputs = myModule(imgs)
    print(imgs.shape) # torch.Size([64, 3, 32, 32]) 通道数3
    print(outputs.shape) # torch.Size([64, 6, 30, 30]) 通道数6

添加tensorboard

  • 注意将outputs的6通道转为3通道显示，否则报错。
import torch
import torchvision
from torch import nn
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=64)

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        output = self.conv1(x)
        return output

myModule = MyModule()
print(myModule)
# MyModule(
#   (conv1): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
# )

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, targets = data
    outputs = myModule(imgs)
    # print(imgs.shape) # torch.Size([64, 3, 32, 32]) 通道数3
    # print(outputs.shape) # torch.Size([64, 6, 30, 30]) 通道数6
    writer.add_images("input", imgs, step)

    # 需要注意的是:显示彩色图是3通道，但output为6通道，因此需要reshape。[64, 6, 30, 30]  --> [xxx, 3, 30, 30]
    outputs = torch.reshape(outputs, (-1, 3, 30, 30)) # -1代表不确定，需要计算机去计算
    writer.add_images("output", outputs, step)
    step = step + 1

writer.close()
  • tensorboard显示
    在这里插入图片描述

神经网络 - 最大池化层

简单使用

  • 最大池化层也称做向下采样层
  • torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
  • kernel_size：卷积核的尺寸，int or tuple
  • stride：卷积核的移动步径，默认值就是kernel_size
  • padding：输入图像周围的填充
  • dilation：卷积核数值间的距离，默认为1，就是没有距离，这里容易造成误解
  • ceil_mode：True为ceil模式，保留余下的数据，False为floor模式，丢弃余下的数据
  • 最大池化操作演示
    在这里插入图片描述
  • 注意最大池化层要求输入的数据是浮点型，注意数据类型转换。
import torch

# MaxPool2d(kernel_size, stride = kernel_size, padding = 0, dilation = 1, return_indices=False,
# ceil_mode = False)
# 参数kernel_size
# 参数stride默认为kernel_size
# 参数ceil_mode为True时，ceil模式，保留：为False时，floor模式，丢弃。
# 输入shape是(N, C, H, W)，输出shape是(N, C, H, W)
from torch import nn
from torch.nn import MaxPool2d

# 池化层要求数据是浮点型
# 否则报错 RuntimeError: "max_pool2d" not implemented for 'Long'
input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]], dtype=torch.float32)
# 输入的shape是（N, C, H, W）
input = torch.reshape(input, (-1, 1, 5, 5))
print(input.shape)

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False)

    def forward(self, x):
        output = self.maxpool1(x)
        return output

myModule = MyModule()
output = myModule(input)
print(output)
# 当ceil_mode为True时，为ceil模式，输出为
# tensor([[[[2., 3.],
#           [5., 1.]]]])
# 当ceil_mode为False时，为floor模式，输出为
# tensor([[[[2.]]]])

作用

  • 保留数据特征的同时，减少数据量
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

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

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False)

    def forward(self, x):
        output = self.maxpool1(x)
        return output

myModule = MyModule()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    outputs = myModule(imgs)
    writer.add_images("output", outputs, step)
    step += 1
writer.close()
  • tensorboard显示
    在这里插入图片描述

神经网络 - 非线性激活

ReLU

  • 此版本torch的ReLU层对输入没有shape要求，低版本可能会要求(N, *)尺寸
  • 参数inplace，是否在原位置修改
    在这里插入图片描述
import torch

# ReLU()
# 小于0，截断为0，大于0，y=x
# 参数inplace，是否在原位置修改，若input=-1，经过ReLU(input, inplace=True)，则input=0；
# 经过output = ReLU(input, inplace=False)，则input仍为-1，output=0
from torch import nn
from torch.nn import ReLU

input = torch.tensor([[1, -0.5],
                      [-1, 3]])

# 此版本torch的ReLU层对输入没有shape要求，低版本可能会要求(N, *)尺寸

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.relu1 = ReLU(inplace=False)

    def forward(self, x):
        output = self.relu1(x)
        return output

myModule = MyModule()
output = myModule(input)
print(output)
# tensor([[1., 0.],
#         [0., 3.]])

Sigmoid

  • 原理
    在这里插入图片描述
  • 代码
import torchvision
from torch import nn
from torch.nn import Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

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

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.sigmoid1 = Sigmoid()

    def forward(self, x):
        output = self.sigmoid1(x)
        return output

myModule = MyModule()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    outputs = myModule(imgs)
    writer.add_images("output", outputs, step)
    step += 1
writer.close()
  • tensorboard显示
    在这里插入图片描述

神经网络 - 线性层

简单介绍

  • 针对数据特征的变换

  • torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

  • 参数in_feartures代表输入层的特征数

  • 参数out_features代表输出层的特征数

  • 参数bias代表偏置
    在这里插入图片描述

  • 对于上图来说，第一个线性层中，in_features为d，out_features为L。第二个线性层中，in_features为L，out_features为m。

  • 线性层中涉及两个变量，weight和bias，即上图中的k和b。
    在这里插入图片描述

VGG16网络中的线性层实现

简单介绍

  • 在经典VGG16网络中，最后1x1x4096到1x1x1000的变化，便是线性层的作用。
    在这里插入图片描述
# Linear(in_features, out_features)
# 参数in_features为输入层的特征数
# 参数out_features为输出层的特征数
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

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

dataloader = DataLoader(dataset, batch_size=64)


class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.linear1 = Linear(196608, 1000)

    def forward(self, x):
        x = self.linear1(x)
        return x

myModule = MyModule()

for data in dataloader:
    imgs, targets = data
    # print(imgs.shape) # torch.Size([64, 3, 32, 32])
    imgs = torch.reshape(imgs, (1, 1, 1, -1)) # torch.Size([1, 1, 1, 196608])
    outputs = myModule(imgs) # torch.Size([1, 1, 1, 1000])
    # print(outputs.shape)
  • 由于涉及将shape由(N, C , H, W)转换成(1, 1, 1, *)，改进reshape()，使用flatten()
...
for data in dataloader:
    imgs, targets = data
    # print(imgs.shape) # torch.Size([64, 3, 32, 32])
    # imgs = torch.reshape(imgs, (1, 1, 1, -1)) # torch.Size([1, 1, 1, 196608])
    imgs = torch.flatten(imgs) # torch.Size([196608])
    outputs = myModule(imgs) # torch.Size([1, 1, 1, 1000])<-reshpae()  # torch.Size([1008])<-flatten()
    # print(outputs.shape)

注意

  • 虽然举例VGG16网络中的线性层是在一维特征上进行的变换，但不代表线性层的输入shape只能是(1, 1, 1, *)这种形式。
  • 看1.12.0版本的torch官方文档，Linear层多维变换都可以。
    在这里插入图片描述
    在这里插入图片描述

搭建网络模型和Sequential使用

CIFAR10网络模型

  • 以CIFAR10 mode为例，建立网络模型，其结构图如下
    在这里插入图片描述

  • 再根据神经网络结构图，搭建网络模型时，需要计算的是卷积层中的stride和padding。

  • 根据官方提供的计算公式，如下：
    在这里插入图片描述

  • 以第一层卷积层为例子，in_channels = 3，out_channels=32; Hin=32，Win=32；Hout=32，Wout=32; kernel_size=5

  • 注意，当stride/padding/dilation为int时，其sride[0]=stride[1]=int，padding[0]=padding[1]=int，dilation[0]=dilation[1]=int。

  • 将已知量带入公式，可计算得到stride=1，padding=2。

  • 搭建网络模型代码

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear


class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = Conv2d(3, 32, 5, stride=1, padding=2) # dilation默认为1
        self.maxpool1 = MaxPool2d(2)
        self.conv2 = Conv2d(32, 32, 5, stride=1, padding=2)
        self.maxpool2 = MaxPool2d(2)
        self.conv3 = Conv2d(32, 64, 5, stride=1, padding=2)
        self.maxpool3 = MaxPool2d(2)
        self.flatten = Flatten() # flatten()也有其对应的Flatten层，摊平层
        self.linear1 = Linear(64*4*4, 64)
        self.linear2 = Linear(64, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.flatten(x)
        x = self.linear1(x)
        x = self.linear2(x)
        return x

myModule = MyModule()
print(myModule)
# MyModule(
#   (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (linear1): Linear(in_features=1024, out_features=64, bias=True)
#   (linear2): Linear(in_features=64, out_features=10, bias=True)
# )

# 测试搭建网络是否正确
input = torch.ones((64, 3, 32, 32)) # batch_size不可缺少，卷积层需要，可简单理解为多少张图片
output = myModule(input)
print(output.shape) # torch.Size([64, 10]) 检验正确

Sequential类

  • 利用sequential简化上述代码
  • 添加tensorboard显示网络骨架
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential


class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, stride=1, padding=2),  # dilation默认为1
            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

myModule = MyModule()
print(myModule)
# MyModule(
#   (model1): Sequential(
#     (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (6): Flatten(start_dim=1, end_dim=-1)
#     (7): Linear(in_features=1024, out_features=64, bias=True)
#     (8): Linear(in_features=64, out_features=10, bias=True)
#   )
# )

# 测试搭建网络是否正确
input = torch.ones((64, 3, 32, 32)) # batch_size不可缺少，卷积层需要，可简单理解为多少张图片
output = myModule(input)
print(output.shape) # torch.Size([64, 10]) 检验正确

# 添加tensorboard显示网络骨架
writer = SummaryWriter("logs")
writer.add_graph(model=myModule, input_to_model=input)
writer.close()
  • tensorboard显示 – 双击放大
    在这里插入图片描述

损失函数和反向传播

  • 损失函数的作用
    • 计算实际输出和目标之间的差距
    • 为我们更新输出提供一定的依据（反向传播）

L1Loss 和 MSELoss

  • 此版本torch(1.12.0)对输入和目标shape无要求，均为（*）
  • 但input.shape和target.shape要一致
  • 输入和目标的数据要为浮点型
# torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')
# L1Loss类对输入和目标shape无要求，都是(*)
import torch
from torch.nn import L1Loss
from torch import nn

# L1Loss要求输入数据是浮点形
inputs = torch.tensor([1, 2, 3], dtype=torch.float32)
targets = torch.tensor([1, 2, 5], dtype=torch.float32)

loss = L1Loss() # 默认 reduction = “mean"
result = loss(inputs, targets) # tensor(0.6667)
print(result)

# torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')
# # MSELoss类对输入和目标shape无要求，都是(*)

# 平方差Loss
loss_mse = nn.MSELoss()
result2 = loss_mse(inputs, targets) # tensor(1.3333)
print(result2)

# 交叉熵Loss
input = torch.tensor([0.1, 0.2, 0.3])

CrossEntropyLoss

  • 交叉熵Loss
  • 适用于分类问题中
  • torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=- 100, reduce=None, reduction=‘mean’, label_smoothing=0.0)
  • 按照输入shape为 (N, C)，目标shape为 (N)
  • 其中C= number of classes ； N = batch size
  • 举例
    在这里插入图片描述
  • 代码
# 交叉熵Loss
# CrossEntropyLoss（）
# 按照输入shape为(N, C)，目标shape为(N)
# 其中N = number of classes  N = batch size
import torch
from torch import nn

input = torch.tensor([0.1, 0.2, 0.3])
target = torch.tensor([1])
loss_cross = nn.CrossEntropyLoss()
# 输入shape需要为(N, C)
input = torch.reshape(input, (1, 3))
result3 = loss_cross(input, target)
print(result3)

网络中损失函数的计算和反向传播

  • 反向传播：计算节点梯度，优化网络中的参数
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

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

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10),
        )

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

myModule = MyModule()
# 交叉熵损失
loss = nn.CrossEntropyLoss()
for data in dataloader:
    imgs, targets = data
    outputs = myModule(imgs)
    # outputs --> tensor([[-0.1541, -0.0937, -0.0411,  0.0405,  0.0265, -0.0111,  0.0820, -0.1124,
    #           0.0817, -0.0898]], grad_fn=<AddmmBackward0>)
    # targets --> tensor([7])
    result_loss = loss(outputs, targets) # result_loss --> tensor(2.2170, grad_fn=<NllLossBackward0>)
    # 反向传播，计算节点梯度，根据梯度来优化网络参数
    result_loss.backward()

优化器

简单使用

  • 优化器根据梯度对参数进行调整，降低损失
  • *torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False, , maximize=False, foreach=None)
  • 参数params代表网络模型中的参数
  • 参数lr = learining rate，学习速率。
  • lr不能太大，也不能太小，太大会造成模型训练起来不稳定，太小训练比较慢。
  • 建议刚开始lr大一些，后面就小一些。
  • 其余参数为算法SGD本身特有的，初学时可以直接使用默认即可。
  • 使用三步走：
    • 对每个节点对应的梯度清0。 optim.zero_grad()
    • 反向传播，计算节点梯度。result_loss.backward()
    • 根据节点中的梯度对参数进行调优。optim.step()
# torch.optim.SGD(params, lr=<required parameter>, momentum=0, dampening=0, weight_decay=0, nesterov=False, *, maximize=False, foreach=None)
# 参数params代表网络模型中的参数
# 参数lr = learining rate，学习速率。
# lr不能太大，也不能太小，太大会造成模型训练起来不稳定，太小训练比较慢。
# 建议刚开始lr大一些，后面就小一些。
# 其余参数为算法SGD本身特有的，初学时可以直接使用默认即可。
import torch
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

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

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10),
        )

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

myModule = MyModule()

# 损失函数
loss = nn.CrossEntropyLoss()
# 优化器
optim = torch.optim.SGD(myModule.parameters(), lr = 0.01)
for data in dataloader:
    imgs, targets = data
    outputs = myModule(imgs)
    result_loss = loss(outputs, targets)
    # 对每个节点对应的梯度清0，由于上一次的梯度对于本次的梯度更新是没有用处的。
    optim.zero_grad()
    # 反向传播，计算节点梯度
    result_loss.backward()
    # 根据节点中的梯度对参数进行调优
    optim.step()

epoch - 多轮训练（类似于多打几轮牌）

  • 单纯进行一轮训练，没有任何意义，需要进行多轮训练。
  • 损失看的是进行一轮训练损失的总和。
  • 注意以下程序的结果，通过google colab跑出，自己电脑上没有英伟达GPU。
import torch
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

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

class MyModule(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10),
        )

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

myModule = MyModule()

# 损失函数
loss = nn.CrossEntropyLoss()
# 优化器
optim = torch.optim.SGD(myModule.parameters(), lr = 0.01)

for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = myModule(imgs)
        result_loss = loss(outputs, targets)
        # 对每个节点对应的梯度清0，由于上一次的梯度对于本次的梯度更新是没有用处的。
        optim.zero_grad()
        # 反向传播，计算节点梯度
        result_loss.backward()
        # 根据节点中的梯度对参数进行调优
        optim.step()
        running_loss = running_loss + result_loss
    print(running_loss)
  • colab结果
    在这里插入图片描述
L-FHy
关注
  • 10
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch深度学习快速入门精简教程
一行一生
11-08 340
神经网络的典型训练过程如下： 定义具有一些可学习参数（或权重）的神经网络 遍历输入数据集 通过网络处理输入 计算损失（输出正确的距离有多远） 将梯度传播回网络参数 通常使用简单的更新规则来更新网络的权重：weight=weight-learning_rate*gradient 待续。。。。。。。。。。。。。。。。。。。。 ...
Pytorch入门实战学习笔记
04-24
根据学习b站当中的pyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】 所做的一些笔记和代码整合。附上学习视频链接https://www.bilibili.com/video/BV1hE411t7RN?spm_id_from=333.337.search-card.all.click
Pytorch深度学习快速入门教程 -- 土堆教程笔记（一）
weixin_43636084的博客
07-25 1311
Pytorch入门学习（一）
小土堆pytorch深度学习记录
最新发布
weixin_45803006的博客
05-31 837
b站小土堆深度学习课程学习记录
[土堆]深度学习快速入门教程笔记——损失函数、反向传播与优化器——013
m0_73697075的博客
10-28 166
损失函数能够量化模型的预测结果与实际标签之间的误差。通过最小化损失函数，我们可以使得模型的预测结果尽可能接近实际标签，从而提高模型的性能。在训练过程中，优化算法（比如梯度下降）使用损失函数的梯度信息来更新模型参数。通过最小化损失函数，模型可以根据训练数据不断调整自身的参数，使得预测结果更加准确。
[土堆]深度学习快速入门教程笔记——线性层及其他层——011
m0_73697075的博客
10-27 1197
神经网络是一种受到人脑神经元结构启发的计算模型，用于机器学习和人工智能任务。它由大量相互连接的人工神经元（也称为节点或神经元）组成，这些神经元按层次排列，分为输入层、隐藏层（可以有多个）和输出层。
深度学习 模型的导入和读取 土堆教程
qishanbaby的博客
07-22 411
【代码】深度学习 模型的导入和读取 土堆教程。
PyTorch深度学习快速入门教程.zip
03-27
PyTorch深度学习快速入门教程是一份非常实用的资源，旨在帮助初学者迅速掌握PyTorch这一强大的深度学习框架。PyTorch以其易用性、灵活性和强大的动态计算图功能而受到广泛赞誉，是许多研究人员和开发者的首选工具。...
PyTorch 深度学习快速入门教程
07-17
PyTorch深度学习快速入门教程旨在为初学者提供一个易懂且全面的指南，让你能够迅速掌握使用PyTorch进行深度学习的基本技能。PyTorch是Facebook开发的一个开源机器学习库，以其灵活性和易用性在学术界和工业界广受...
深度学习与PyTorch入门实战教程-网盘链接和密码-永久有效-详细教程
06-11
这是一套深度学习与PyTorch入门实战教程，适合学习深度学习的学者和PyTorch学习者，由于视频比较大只能通过网盘分享，上传的文件里是网盘链接和密码。章节包括以下内容：01 介绍；02 深度学习初见；03 基础张量操作...
PyTorch深度学习开发医学影像-视频教程网盘链接提取码下载 .txt
07-17
PyTorch是一个深度学习框架，它提供了各种工具和功能来构建、训练和部署深度学习模型。相比其他深度学习框架，例如TensorFlow，PyTorch更加易于使用和灵活。在PyTorch中，我们可以使用张量（tensor）对象来存储和...
深度学习PyTorch极简入门PDF教程1
08-03
【深度学习PyTorch极简入门PDF教程1】 深度学习是一种机器学习的分支，它主要依赖于多层的神经网络架构来实现复杂的学习任务。在深度学习中，这些多层的神经网络通过逐层处理输入数据，从底层的简单特征到高层的...
土堆pytorch教程学习笔记 （所有代码笔记超详细完整版）
tlytjj的博客
11-16 961
目录一. read_data二. dataloader三. transforms四。五. conv六.conv2d七.loss八.linear九.loss-network十.pool十一.RELU十二.sqc十三.test-tensorboard十四.optim十五.model十六.test-modle十七.model-pretained十八.model-save十九.model-load二十.train二十一.train-gpu1。
pytorch小土堆
yfuyu的博客
03-12 839
小土堆 基础的卷积神经网络pytorch代码学习
【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记并附练习代码 ipynb文件）
几度热忱的博客
03-28 3582
【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记 文末附练习代码 ipynb文件）
pytorch入门教程（小土堆
linyuxi_loretta的博客
11-16 784
pytorch入门教程、一些基础函数的概念（参考代码），主要是带着读了一遍pytorch官方文档、另外推荐一个网站 www.paperswithcode.com，感觉很厉害的样子。
pytorch深度学习小土堆的训练模型
weixin_44095244的博客
10-06 440
1.将建立的深度学习的模型放入一个py文件中，在mian函数中进行全1的模型检测 import torch from torch import nn from torch.nn import Conv2d, MaxPool2d, Flatten,Linear,Sequential class Tudui(nn.Module): def __init__(self): super(Tudui, self).__init__() self.model1 = Sequ
【土堆pytorch】入门P1-P15 基础知识
问就ycy的博客
09-10 498
视频内容来自哔哩哔哩小土堆【PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】】 https://www.bilibili.com/video/BV1hE411t7RN?share_source=copy_web&vd_source=36a92e9d41430f3515d65a4df288f493 供自己以后复习用
小土堆Pytorch快速入门-ch01
欢迎大家一起交流学习！
10-25 858
小土堆Pytorch学习笔记
深度学习入门Python教程 - 基础篇
"这篇教程是为深度学习初学者准备的Python快速入门教程，主要涵盖了Python的基础语法和与深度学习相关的基础知识，如numpy和Matplotlib的使用。教程由荷兰程序员Guido van Rossum创造的Python语言引入，强调其简单性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值