Pytorch学习 day11（优化器、使用和修改现有网络模型）

已于 2024-03-26 20:51:11 修改
阅读量615 收藏 7
点赞数 18
分类专栏： Pytorch 文章标签： pytorch 学习 人工智能
于 2024-03-11 20:27:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011453680/article/details/136633810
版权

优化器

  • 在模型的训练过程中，我们根据反向传播来获取每个网络节点的对应梯度，之后通过某种算法（优化器）根据对应梯度来不断更新节点的参数，最终达到最小loss的结果。
  • 优化器有很多，但有两个参数是所有优化器都有的：
    • 模型的节点参数、学习率，其中：学习率是我们手动指定的，一般都为较小的数，如下：
      在这里插入图片描述
  • 以下为使用优化器的步骤：
    • 注意，在每次反向传播（backward）之前，需要进行梯度清零（zero_grad）。
      • 因为在反向传播过程中，计算出的梯度会累积在模型的参数中。如果不进行梯度清零，那么在下一次反向传播时，当前的梯度会与上一次的梯度累加，导致更新参数时的梯度方向不准确，从而影响模型的收敛性和性能。所以为了确保每次的反向传播都是计算的当前参数下的梯度，需要进行梯度清零。
        在这里插入图片描述
    • 下图中的data为网络节点参数，grad为梯度：
      在这里插入图片描述
  • 以下为采用SGD优化器，并结合上一节的交叉熵损失函数，对CIFAR10数据集进行分类的模型代码：
    • 这里我们将每轮中每个预测的loss加和，作为该轮模型的整体loss进行输出
import torch
import torchvision
from torch import nn


test_dataset = torchvision.datasets.CIFAR10(root='Dataset', train=False, download=True, transform=torchvision.transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=False)

class Tudui(nn.Module):
    def __init__(self):
        super().__init__()
        self.module1 = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10)
        )
    def forward(self, input):
        output = self.module1(input)
        return output

loss = nn.CrossEntropyLoss()    # 交叉熵损失函数
tudui = Tudui()
optim = torch.optim.SGD(tudui.parameters(), lr=0.01)    # SGD优化器 随机梯度下降

for epoch in range(20):
    runnning_loss = 0.0
    for data in test_loader:
        inputs, targets = data
        outputs = tudui(inputs)
        result_loss = loss(outputs, targets)    # 计算loss
        optim.zero_grad()    # 梯度清零，注意需要在反向传播之前
        result_loss.backward()  # 反向传播，计算梯度，注意需要使用计算后的loss
        optim.step()    # 更新参数
        runnning_loss += result_loss
    print(f'epoch: {epoch}, loss: {runnning_loss}')

使用和修改现有网络模型

  • 在我们不使用预训练的网络模型时，模型各节点的参数都是默认设置。如果我们更换预训练的模型，则节点参数是已经在某个数据集上训练好的，可以达到一个比较好的输出结果
  • VGG16模型的用法：
    • 注意：当weights = None时，表示不使用预训练的网络模型，节点参数使用默认设置
    • 当weights = 'DEFAULT’时，表示使用预训练的网络模型
      在这里插入图片描述
  • 以下是VGG16在ImageNet数据集上，使用预训练的节点参数：
    在这里插入图片描述
  • 以下为VGG16的默认节点参数：
    在这里插入图片描述
  • 可以打印VGG16的模型结构，代码如下：
    • 由最后的输出结果可以看出VGG16的预测类别为1000类，符合ImageNet数据集的类别
import torch
import torchvision
import torch.nn as nn

# train_dataset = torchvision.datasets.ImageNet(root = 'Dataset', split='train', download=True, transform=torchvision.transforms.ToTensor())
# 由于数据集太大，现在已经不提供下载，报错如下：
# RuntimeError: The archive ILSVRC2012_devkit_t12.tar.gz is not present in the root directory or is corrupted. You need to download it externally and place it in Dataset.
vgg16_false = torchvision.models.vgg16(weights=None)
vgg16_true = torchvision.models.vgg16(weights="DEFAULT")

print(vgg16_false)

# 输出结果：
# VGG(
#   (features): Sequential(
#     (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (1): ReLU(inplace=True)
#     (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (3): ReLU(inplace=True)
#     (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (6): ReLU(inplace=True)
#     (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (8): ReLU(inplace=True)
#     (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (11): ReLU(inplace=True)
#     (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (13): ReLU(inplace=True)
#     (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (15): ReLU(inplace=True)
#     (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#      (18): ReLU(inplace=True)
#     (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (20): ReLU(inplace=True)
#     (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (22): ReLU(inplace=True)
#     (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (25): ReLU(inplace=True)
#     (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (27): ReLU(inplace=True)
#     (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (29): ReLU(inplace=True)
#     (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   )
#   (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
#   (classifier): Sequential(
#     (0): Linear(in_features=25088, out_features=4096, bias=True)
#     (1): ReLU(inplace=True)
#     (2): Dropout(p=0.5, inplace=False)
#     (3): Linear(in_features=4096, out_features=4096, bias=True)
#     (4): ReLU(inplace=True)
#     (5): Dropout(p=0.5, inplace=False)
#     (6): Linear(in_features=4096, out_features=1000, bias=True)
#   )
# )

在这里插入图片描述

  • 由于CIFAR10数据集只有10各类别，所以我们可以修改VGG16的最后一层的输出，将1000改为10，或者再添加一层将1000转为10。
    • 可以使用 .add_module(name, module)函数。
      • name：表示添加层的名字
      • module：表示添加的层，如nn.Linear()、nn.Conv2d()、nn.Sequential()均可
  • 添加一层的代码如下：
    • 如果我们直接用模型名.add_module()，那么我们添加的层是在模型的最末端
    • 我们也可以使用模型名.sequential名.add_module()的形式，那么我们添加的层就是在该sequential的最末端
import torch
import torchvision
import torch.nn as nn

# train_dataset = torchvision.datasets.ImageNet(root = 'Dataset', split='train', download=True, transform=torchvision.transforms.ToTensor())
# 由于数据集太大，现在已经不提供下载，报错如下：
# RuntimeError: The archive ILSVRC2012_devkit_t12.tar.gz is not present in the root directory or is corrupted. You need to download it externally and place it in Dataset.
vgg16_false = torchvision.models.vgg16(weights=None)
vgg16_true = torchvision.models.vgg16(weights="DEFAULT")

# print(vgg16_false)
# print(vgg16_true)

test_dataset = torchvision.datasets.CIFAR10(root = 'Dataset', train=False, download=True, transform=torchvision.transforms.ToTensor())
vgg16_true.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)

# 输出结果：
# VGG(
#   (features): Sequential(
#     (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (1): ReLU(inplace=True)
#     (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (3): ReLU(inplace=True)
#     (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (6): ReLU(inplace=True)
#     (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (8): ReLU(inplace=True)
#     (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (11): ReLU(inplace=True)
#     (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (13): ReLU(inplace=True)
#     (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (15): ReLU(inplace=True)
#     (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#      (18): ReLU(inplace=True)
#     (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (20): ReLU(inplace=True)
#     (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (22): ReLU(inplace=True)
#     (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (25): ReLU(inplace=True)
#     (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (27): ReLU(inplace=True)
#     (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (29): ReLU(inplace=True)
#     (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   )
#   (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
#   (classifier): Sequential(
#     (0): Linear(in_features=25088, out_features=4096, bias=True)
#     (1): ReLU(inplace=True)
#     (2): Dropout(p=0.5, inplace=False)
#     (3): Linear(in_features=4096, out_features=4096, bias=True)
#     (4): ReLU(inplace=True)
#     (5): Dropout(p=0.5, inplace=False)
#     (6): Linear(in_features=4096, out_features=1000, bias=True)
#   )
#   (add_linear): Linear(in_features=1000, out_features=10, bias=True)
# )
  • 修改一层的代码如下：
    • 可以通过模型实例.层名的方法来修改某一层，如果为该层为sequential，那么层名后加 [ ] 可以指定sequential中的第几层
import torch
import torchvision
import torch.nn as nn

# train_dataset = torchvision.datasets.ImageNet(root = 'Dataset', split='train', download=True, transform=torchvision.transforms.ToTensor())
# 由于数据集太大，现在已经不提供下载，报错如下：
# RuntimeError: The archive ILSVRC2012_devkit_t12.tar.gz is not present in the root directory or is corrupted. You need to download it externally and place it in Dataset.
vgg16_false = torchvision.models.vgg16(weights=None)
vgg16_true = torchvision.models.vgg16(weights="DEFAULT")

# print(vgg16_false)
# print(vgg16_true)

test_dataset = torchvision.datasets.CIFAR10(root = 'Dataset', train=False, download=True, transform=torchvision.transforms.ToTensor())
vgg16_true.classifier[6]=nn.Linear(1000, 10)
print(vgg16_true)

# 输出结果：
# VGG(
#   (features): Sequential(
#     (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (1): ReLU(inplace=True)
#     (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (3): ReLU(inplace=True)
#     (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (6): ReLU(inplace=True)
#     (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (8): ReLU(inplace=True)
#     (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (11): ReLU(inplace=True)
#     (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (13): ReLU(inplace=True)
#     (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (15): ReLU(inplace=True)
#     (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#      (18): ReLU(inplace=True)
#     (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (20): ReLU(inplace=True)
#     (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (22): ReLU(inplace=True)
#     (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (25): ReLU(inplace=True)
#     (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (27): ReLU(inplace=True)
#     (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (29): ReLU(inplace=True)
#     (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   )
#   (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
#   (classifier): Sequential(
#     (0): Linear(in_features=25088, out_features=4096, bias=True)
#     (1): ReLU(inplace=True)
#     (2): Dropout(p=0.5, inplace=False)
#     (3): Linear(in_features=4096, out_features=4096, bias=True)
#     (4): ReLU(inplace=True)
#     (5): Dropout(p=0.5, inplace=False)
#     (6): Linear(in_features=4096, out_features=10, bias=True)
#   )
# )
丿罗小黑
关注
  • 18
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
在pytorch中动态调整优化器的学习率方式
09-16
主要介绍了在pytorch中动态调整优化器的学习率方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
神经网络-网络模型的使用及修改、保存与读取
weixin_48139224的博客
08-14 578
太大太慢了，没办法使用imagenet数据集去验证VGG16模型中参数pretrain了，改变策略：把这个参数设置为TRUE/FALSE，去看看下载的网络模型差别。pretrained=TRUE时，才是从网络中进行下载，VGG16网络模型中的一些参数都是在数据集上训练好的。思路二：在线性层下面加一层，使in_features=1000,out_features=10。分类结果：输出为1000，即在imagenet上训练后的结果。（2）查看vgg16模型在imagenet数据集上训练的结果。
【pytorch】如何在pytorch自定义优化函数？
快睡吧风的博客
08-17 8129
pytorch 可以说是最简单易学的深度学习库了，为了加快神经网络的学习效率我们通常会使用一些加速技巧，但很多人都是使用的torch.optim自带的优化器，本文就将介绍如何自定义一个优化器并比较其与主流算法的加速效果 1.准备工作 首先下载minst数据库作为测试数据集合minst 我们需要train-images.idx3-ubyte和train-labels.idx1-ub...
对比pytorch的优化器实现及使用方法MindSporeAI
skytttttt9394的博客
08-18 747
MindSpore和pytorch都支持参数分组且使用方法相似，在使用时都是给优化器传入一个字典的列表，每个字典对应一个参数组，其中key为参数名，value为对应的设置值。Mindspore中的混合精度场景下，如果使用FixedLossScaleManager进行溢出检测，且drop_overflow_update为False时，优化器需设置loss_scale的值，且loss_scale值与FixedLossScaleManager的相同，详细使用方法可以参考优化器的混合精度配置。
pytorch 自定义损失函数、优化器（Optimizer）和学习率策略（Scheduler）
zhaohongfei_358的博客
07-14 7421
梯度下降回顾 Pytorch 实现梯度下降与参数更新 自定义损失函数 自定义优化器 自定义学习率策略 使用 `LambdaLR` 实现简单的学习率策略 通过继承 `_LRScheduler` 实现自定义的学习率策略 通过手动更新Optimizer中的学习率来自定义学习策略......
Pytorch——损失函数
qq_42374603的博客
01-25 314
1.常见损失函数 1.1 L1loss 例子： x = torch.Tensor([1, 2, 3]) y = torch.Tensor([1, 0, 6]) L1loss = nn.L1Loss() loss1 = L1loss(x, y) print(loss1) 输出： tensor(1.6667) 1.2 MSELoss 例子： x = torch.Tensor([1, 2, 3]) y = torch.Tensor([1, 0, 6]) mseloss = nn.MSELoss() los
PyTorch 模型训练实用教程（五）：优化器基类/十种优化器/六个学习率调整⽅法
qq_38156104的博客
09-18 1700
目录 优化器基类 Optimizer 参数组(param_groups)的概念 zero_grad() state_dict() load_state_dict(state_dict) add_param_group() step(closure) PyTorch 的⼗个优化器 torch.optim.SGD torch.optim.ASGD torch.optim.Rprop torch.optim.Adagrad torch.optim.Adadelta torch.opt.
pytorch 实现在一个优化器中设置多个网络参数的例子
09-17
今天小编就为大家分享一篇pytorch 实现在一个优化器中设置多个网络参数的例子，具有很好参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
基于Pytorch的风格转换生成深度学习网络模型训练和测试实现
最新发布
05-31
本程序实现了基于Pytorch的风格转换生成网络深度学习网络训练和测试实现，适合基于Pytorch的深度学习搭建以及风格转换生成模型的设计，可供风格转换生成网络模型学习和使用。
使用 PyTorch 实现的深度学习 ECG 模型
04-02
在心电图（ECG）领域，研究人员利用 PyTorch 来开发深度学习模型，用于识别心脏疾病和异常。这些模型可以从心电图数据中学习复杂的特征，帮助医生进行准确的诊断和预测。 一种常见的深度学习 ECG 模型是卷积神经网络...
浅谈Pytorch torch.optim优化器个性化的使用
12-20
一、简化前馈网络LeNet import torch as t class LeNet(t.nn.Module): def __init__(self): super(LeNet, self).__init__() self.features = t.nn.Sequential( t.nn.Conv2d(3, 6, 5), t.nn.ReLU(), t.nn.MaxPool2d(2, 2), t.nn.Conv2d(6, 16, 5), t.nn.ReLU(), t.nn.MaxPool2d(2, 2) ) # 由于调整shape并不是一
Pytorch参数优化
weixin_61765266的博客
07-26 558
当我们训练神经网络时，我们需要调整模型的参数，使得损失函数的值逐渐减小，从而优化模型。但是模型的参数我们一般是无法看见的，所以我们必须学会对参数的更新，下面，我将介绍两种参数更新的方法。
【pytorch】optimizer（优化器）的使用详解
热门推荐
学渣的博客
10-26 2万+
本文介绍包常见的 torch.optim 的使用方法和使用技巧。
Pytorch模型使用与修改、保存与加载
北山啦的博客
11-14 297
本文介绍Pytorch模型使用与修改、保存与加载。将以图像处理中torchvision为例，PyTorch通过torchvision.models模块提供了更多的预训练模型。
pytorch使用Ray-tune对原有训练模型的代码改写，自动调参（一）
呆萌的代Ma
08-11 3365
借助Ray-tune可以对pytorch自动调参，下面就一步步地改写，从原始的训练代码慢慢变为可以自动调参的代码的教程• 保姆级： 安装依赖 pip install -i https://mirrors.aliyun.com/pypi/simple/ 'ray[default]' 注意安装的内容是'ray[default]'，因为后来的各版本代码有调整，因此统一指定成了这种安装方式，否则代码运行中会有各种warnning。 pytorch模型自动调参 为了增加学习效率，这里举一个没有加任何额外的buff的
pytorch修改网络模型案例
weixin_43751285的博客
04-03 547
以resnet为例子 已经使用该方法修改好网络，定个眼。后续学习。
现有网络模型的使用及修改
红凯的博客
05-23 132
VGG分类模型
pytorch中的pretrain模型网络结构修改
忽逢桃林的博客
02-01 1859
pytorch中的pretrain模型网络结构修改 继上篇文章提出的两种预训练模型的修改方法外，今天在这里推荐我新学习到的一种方法： 这里还是以resnet模型为参考，在去掉预训练resnet模型的后两层(fc层和pooling层)后，新添加一个反卷积层、池化层和分类层。 那么对于网络的修改怎样可以快速的去除model本身的网络层呢？ 一个继承nn.module的model它包含一个叫做child...
PyTorch自定义优化器
sunlanchang的博客
12-03 3259
简单粗暴的方法直接更新参数： def myopt(): pre=[] #pre储存当前梯度与历史梯度方向是否一致的信息 lr=[] #lr储存各层各参数学习率 vdw=[] #vdw储存各层各参数动量 y_pred = net(x) loss = loss_func(y_pred, y) net...
如何使用PyTorch中的优化器和学习率调度器
05-26
在PyTorch中，优化器和学习率调度器都是通过torch.optim模块来实现的。 首先，我们需要定义一个优化器，这里以Adam优化器为例： ```python import torch.optim as optim optimizer = optim.Adam(model.parameters(), lr=0.001) ``` 其中，model为我们定义好的神经网络模型，lr为学习率。 接下来，我们可以在训练过程中使用这个优化器来更新模型参数： ```python optimizer.zero_grad() # 清空梯度 outputs = model(inputs) # 前向传播 loss = criterion(outputs, labels) # 计算损失 loss.backward() # 反向传播 optimizer.step() # 更新参数 ``` 在每一轮训练之前，我们需要调用optimizer.zero_grad()来清空梯度。 除了定义优化器之外，我们还可以定义一个学习率调度器，用于动态地调整学习率。PyTorch中提供了多种学习率调度器，这里以StepLR调度器为例： ```python from torch.optim.lr_scheduler import StepLR scheduler = StepLR(optimizer, step_size=10, gamma=0.1) ``` 其中，optimizer为我们定义好的优化器，step_size为每隔多少个epoch调整一次学习率，gamma为学习率调整的倍数。 在每个epoch结束时，我们可以调用scheduler.step()来更新学习率： ```python for epoch in range(num_epochs): # ... scheduler.step() # 更新学习率 ``` 除了StepLR调度器外，PyTorch中还提供了其他调度器，比如MultiStepLR、ExponentialLR等，可以根据具体需求选择。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

丿罗小黑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值