【PyTorch】动态调整学习率 torch.optim.lr_scheduler.StepLR 调度器

news2025/1/6 0:43:18

文章目录

  • 1. torch.optim.lr_scheduler.StepLR 官方文档详解
  • 2. 使用示例
    • 2.1 官方提供使用示例
    • 2.2 自己写代码测试方法
      • 2.2.1 get_last_lr() 方法
      • 2.2.2 state_dict() 方法
      • 2.2.3 load_state_dict() 保存和加载调度器
  • 3. 思考
    • 3.1 为什么需要state_dict()
    • 3.2 get_lr() 与 get_last_lr() 的输出不一致问题

在深度学习中，学习率调度器（Learning Rate Scheduler） 是用来动态调整学习率的工具。它的主要目的是在训练过程中自动调整学习率，以提高训练的效率和效果。之所以称其为“调度器”，是因为它控制着学习率的调整和更新，类似于调度一个过程或者任务，它按照某种策略和规则来“调度”学习率，本文将详细介绍pytorch中动态调整学习率方法之一 torch.optim.lr_scheduler.StepLR

官方文档链接：
https://pytorch.ac.cn/docs/stable/generated/torch.optim.lr_scheduler.StepLR.html#torch.optim.lr_scheduler.StepLR

1. torch.optim.lr_scheduler.StepLR 官方文档详解

官方文档定义:

class torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1, verbose='deprecated')

每隔 step_size 个 epochs 将每个参数组的学习率衰减 gamma 倍。
请注意，这种衰减可能与来自此调度程序外部的学习率的其他更改同时发生。当 last_epoch=-1 时，将初始 lr 设置为 lr。

参数：

  • o p t i m i z e r optimizer optimizer (优化器) : 包装的优化器
  • s t e p _ s i z e ( i n t ) step\_size(int) step_size(int) : 学习率衰减周期
  • g a m m a ( f l o a t ) gamma (float) gamma(float) : 学习率衰减的乘法因子, 默认值：0.1
  • l a s t _ e p o c h ( i n t ) last\_epoch (int) last_epoch(int) : 最后一个 epoch 的索引, 默认值：-1 表示从头开始
  • v e r b o s e ( b o o l ∣ s t r ) verbose (bool | str) verbose(bool∣str): 如果为 True，则为每次更新打印一条消息到标准输出, 默认值：False。

注意：

  • 自版本 2.2 起不推荐使用： v e r b o s e verbose verbose 已弃用。请使用 g e t _ l a s t _ l r ( ) get\_last\_lr() get_last_lr()访问学习率

其它：

  • g e t _ l a s t _ l r ( ) get\_last\_lr() get_last_lr() : 返回当前调度程序计算的最后一个学习率, 返回类型 L i s t [ f l o a t ] List[float] List[float]
  • g e t _ l r ( ) get\_lr() get_lr() : 计算每个组的学习率
  • l o a d _ s t a t e _ d i c t ( s t a t e _ d i c t ) load\_state\_dict(state\_dict) load_state_dict(state_dict) : 加载调度程序的状态，参数： s t a t e _ d i c t ( d i c t ) state\_dict (dict) state_dict(dict) 调度程序状态，应为 s t a t e _ d i c t ( ) state\_dict() state_dict() 调用返回的对象。
  • p r i n t _ l r ( i s _ v e r b o s e , g r o u p , l r , e p o c h = N o n e ) print\_lr(is\_verbose, group, lr, epoch=None) print_lr(is_verbose,group,lr,epoch=None) : 显示当前学习率。
  • s t a t e _ d i c t ( ) state\_dict() state_dict() : 将调度程序的状态作为 d i c t dict dict 返回,它包含 s e l f . _ _ d i c t _ _ self.\_\_dict\_\_ self.__dict__ 中每个变量的条目，这些变量不是优化器。
  • s t e p ( e p o c h = N o n e ) step(epoch=None) step(epoch=None) : 执行一步操作，即更新一次学习率

注意：

  • 自版本 2.4 起不推荐使用： p r i n t _ l r ( ) print\_lr() print_lr() 已弃用。请使用 g e t _ l a s t _ l r ( ) get\_last\_lr() get_last_lr() 访问学习率。

2. 使用示例

2.1 官方提供使用示例

  • 假设初始 l r = 0.05 lr = 0.05 lr=0.05， s t e p _ s i z e = 30 step\_size=30 step_size=30， g a m m a = 0.1 gamma=0.1 gamma=0.1，即每 30 个 epoch后，将学习率乘以 0.1
  • 当 e p o c h < 30 epoch< 30 epoch<30 时， l r = 0.05 lr = 0.05 lr=0.05 ，即 l r = l r lr=lr lr=lr
  • 当 30 < = e p o c h < 60 30 <= epoch < 60 30<=epoch<60 ， l r = 0.005 lr = 0.005 lr=0.005，即 l r n e w = l r o l d ∗ g a m m a = 0.05 ∗ 0.1 = 0.005 lr_{new}=lr_{old}*gamma=0.05*0.1=0.005 lrnew​=lrold​∗gamma=0.05∗0.1=0.005
  • 当 60 < = e p o c h < 90 60 <= epoch < 90 60<=epoch<90 ， l r = 0.0005 lr = 0.0005 lr=0.0005，即 l r n e w = l r o l d ∗ g a m m a = 0.005 ∗ 0.1 = 0.0005 lr_{new}=lr_{old}*gamma=0.005*0.1=0.0005 lrnew​=lrold​∗gamma=0.005∗0.1=0.0005
# Assuming optimizer uses lr = 0.05 for all groups
# lr = 0.05     if epoch < 30
# lr = 0.005    if 30 <= epoch < 60
# lr = 0.0005   if 60 <= epoch < 90
# ...
scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
for epoch in range(100):
    train(...)
    validate(...)
    scheduler.step()

2.2 自己写代码测试方法

2.2.1 get_last_lr() 方法

  • 用于返回调度器计算的 最后一个学习率。这个学习率是在调度器（scheduler）调整之后的当前学习率
  • 如果优化器中有多个参数组， g e t _ l a s t _ l r ( ) get\_last\_lr() get_last_lr() 返回的是一个列表，每个元素对应一个参数组的学习率
  • 如果优化器中只有一个参数组， g e t _ l a s t _ l r ( ) get\_last\_lr() get_last_lr() 返回一个只有一个元素的列表
import torch
from torch import nn
from torch import optim
net = nn.Linear(3,4)
def train():
    optimizer = optim.Adam(net.parameters(), lr=0.1)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 1, gamma=0.1)
    for epoch in range(0, 10):
        print(epoch, scheduler.get_last_lr())
        optimizer.step()
        scheduler.step()
if __name__ == "__main__":
    train()

代码输出：

0 [0.1]
1 [0.010000000000000002]
2 [0.0010000000000000002]
3 [0.00010000000000000003]
4 [1.0000000000000004e-05]
5 [1.0000000000000004e-06]
6 [1.0000000000000005e-07]
7 [1.0000000000000005e-08]
8 [1.0000000000000005e-09]
9 [1.0000000000000006e-10]

2.2.2 state_dict() 方法

  • s t a t e _ d i c t ( ) state\_dict() state_dict() 是一个非常重要的函数，它能够返回一个包含模型或优化器状态的字典（dict）。对于学习率调度器来说， s t a t e _ d i c t ( ) state\_dict() state_dict() 返回调度器的状态，包括它的参数和变量，用于保存和恢复调度器的状态等

代码示例：

import torch
from torch import nn
from torch import optim

net = nn.Linear(3,4)

def train():
    optimizer = optim.Adam(net.parameters(), lr=0.1)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 1, gamma=0.1)
    
    for epoch in range(10):
        print(epoch, scheduler.state_dict())
        optimizer.step()
        scheduler.step()

if __name__ == "__main__":
    train()

代码输出：

0 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 0, 'verbose': False, '_step_count': 1, '_get_lr_called_within_step': False, '_last_lr': [0.1]}
1 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 1, 'verbose': False, '_step_count': 2, '_get_lr_called_within_step': False, '_last_lr': [0.010000000000000002]}   
2 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 2, 'verbose': False, '_step_count': 3, '_get_lr_called_within_step': False, '_last_lr': [0.0010000000000000002]}  
3 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 3, 'verbose': False, '_step_count': 4, '_get_lr_called_within_step': False, '_last_lr': [0.00010000000000000003]} 
4 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 4, 'verbose': False, '_step_count': 5, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000004e-05]} 
5 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 5, 'verbose': False, '_step_count': 6, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000004e-06]} 
6 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 6, 'verbose': False, '_step_count': 7, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000005e-07]} 
7 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 7, 'verbose': False, '_step_count': 8, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000005e-08]} 
8 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 8, 'verbose': False, '_step_count': 9, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000005e-09]} 
9 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 9, 'verbose': False, '_step_count': 10, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000006e-10]}

输出详解：

  • step_size: 该值表示每隔多少个 epoch 学习率就会发生变化。在例子中， s t e p _ s i z e = 1 step\_size = 1 step_size=1，意味着每经过 1 个 epoch，学习率都会更新一次
  • gamma: 这是学习率更新的衰减因子。每次调用 s c h e d u l e r . s t e p ( ) scheduler.step() scheduler.step() 时，当前的学习率将会乘以 g a m m a gamma gamma。例子中， g a m m a = 0.1 gamma = 0.1 gamma=0.1，意味着每次更新学习率时，学习率将减少为原来的 10%
  • base_lrs: 这是每个参数组的初始学习率（在调度器调整之前的学习率）。这里的 [ 0.1 ] [0.1] [0.1]表示模型的初始学习率是 0.1。如果有多个参数组，这里会是一个列表，列出每个参数组的初始学习率
  • last_epoch: 这是上一个 epoch 的编号，用来确定学习率更新时的参考点。 l a s t _ e p o c h = 0 last\_epoch = 0 last_epoch=0 表示调度器刚刚初始化，学习率还没有更新过。通常，last_epoch 用来恢复训练时从哪个 epoch 开始更新学习率
  • verbose: 该参数控制调度器是否在学习率更新时打印详细信息。 v e r b o s e = F a l s e verbose = False verbose=False 表示调度器在更新学习率时不会打印信息。如果设置为 T r u e True True，则每次更新学习率时都会打印一条日志。
  • _step_count: 这个内部变量跟踪调度器已经调用了多少次 step()。在例子中， _ s t e p _ c o u n t = 1 \_step\_count = 1 _step_count=1，表示调度器已经调用过一次 s t e p ( ) step() step()，即更新过一次学习率
  • _get_lr_called_within_step: 是一个内部标志，表示是否在 step() 方法内部调用了 get_lr()。通常不需要关注这个值，它帮助调度器管理内部逻辑
  • _last_lr: 这是调度器最近一次计算的学习率。这个列表保存了每个参数组的学习率。在你的例子中， _ l a s t _ l r = [ 0.1 ] \_last\_lr = [0.1] _last_lr=[0.1]，表示当前学习率是 0.1。这会在 scheduler.step() 后更新为新的学习率。

2.2.3 load_state_dict() 保存和加载调度器

可以将 state_dict() 保存到文件中，然后在以后恢复。如下是一个保存和加载学习率调度器状态的例子：

保存调度器状态：

# 保存调度器的 state_dict
torch.save(scheduler.state_dict(), 'scheduler_state.pth')

加载调度器状态：

# 加载调度器的 state_dict
scheduler.load_state_dict(torch.load('scheduler_state.pth'))

通过这种方式，可以在训练中断后恢复学习率调度器的状态，并继续进行训练。

保存调度器状态示例：

当 epoch = 5 时，保存调度器状态：

import torch
from torch import nn
from torch import optim
net = nn.Linear(3,4)
def train():
    optimizer = optim.Adam(net.parameters(), lr=0.1)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 1, gamma=0.1)

    for epoch in range(10):
        if epoch == 5:
            torch.save(scheduler.state_dict(), 'scheduler_state.pth')
            break
        optimizer.step()
        scheduler.step()

if __name__ == "__main__":
    train()

加载调度器状态示例：

import torch
from torch import nn
from torch import optim

net = nn.Linear(3,4)

def train():
    optimizer = optim.Adam(net.parameters(), lr=0.1)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 1, gamma=0.1)
    scheduler.load_state_dict(torch.load("scheduler_state.pth"))
    for epoch in range(3):
        print(epoch, scheduler.state_dict())
        optimizer.step()
        scheduler.step()

if __name__ == "__main__":
    train()

代码输出：

0 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 5, 'verbose': False, '_step_count': 6, '_get_lr_called_within_step': False, '_last_lr': [1.0000000000000004e-06]}
1 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 6, 'verbose': False, '_step_count': 7, '_get_lr_called_within_step': False, '_last_lr': [0.010000000000000002]}
2 {'step_size': 1, 'gamma': 0.1, 'base_lrs': [0.1], 'last_epoch': 7, 'verbose': False, '_step_count': 8, '_get_lr_called_within_step': False, '_last_lr': [0.0010000000000000002]}

可以看到：

  • last_epoch 从 5 开始
  • _step_count 从6 开始
  • _last_lr 从 1e-6 开始

说明是从上次终断的状态继续运行

3. 思考

3.1 为什么需要state_dict()

  • 保存和恢复训练： 当你希望在训练中断后恢复训练时，你可以保存模型和调度器的 state_dict()，然后在恢复时加载它们，确保学习率调度器从上次停止的地方继续工作，而不是从头开始。
  • 调试和分析：通过 state_dict() 可以查看学习率的变化，帮助你调试和分析训练过程中调度器的行为。

3.2 get_lr() 与 get_last_lr() 的输出不一致问题

测试代码：

import torch
from torch import nn
from torch import optim

net = nn.Linear(3,4)

def train():
    optimizer = optim.Adam(net.parameters(), lr=0.1)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 1, gamma=0.1)
    for epoch in range(3):
        print(epoch, scheduler.get_lr())
        print(epoch, scheduler.get_last_lr())
        print([group["lr"] for group in optimizer.param_groups])
        print("==========================================")
        optimizer.step()
        scheduler.step()

if __name__ == "__main__":
    train()

代码输出：

0 [0.1]
0 [0.1]
[0.1]
==========================================
1 [0.0010000000000000002]
1 [0.010000000000000002]
[0.010000000000000002]
==========================================
2 [0.00010000000000000003]
2 [0.0010000000000000002]
[0.0010000000000000002]
==========================================

不知道为什么从 epoch > 0 之后，get_lr() 每次都比 get_last_lr() 提前一步更新，但是通过查看 optimizer.param_groups 的学习率与 get_last_lr() 一致。

get_lr()函数源码：

def get_lr(self):
    if not self._get_lr_called_within_step:
        warnings.warn("To get the last learning rate computed by the scheduler, "
                      "please use `get_last_lr()`.", UserWarning)

    if (self.last_epoch == 0) or (self.last_epoch % self.step_size != 0):
        return [group['lr'] for group in self.optimizer.param_groups]
    return [group['lr'] * self.gamma
            for group in self.optimizer.param_groups]

我们可以看到在源码中当：if (self.last_epoch == 0) or (self.last_epoch % self.step_size != 0)，返回值为[group['lr'] for group in self.optimizer.param_groups], 否则的话返回值为[group['lr'] * self.gamma for group in self.optimizer.param_groups]，因此可以很好的解释上面的现象，但是Pytorch为什么要这样做呢？？目前没有找到相关资料，可以评论区留言讨论！

get_last_lr() 函数源码:

def get_last_lr(self):
   """ Return last computed learning rate by current scheduler.
   """
   return self._last_lr

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2261350.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

40 基于单片机的温湿度检测判断系统

40 基于单片机的温湿度检测判断系统

目录 一、主要功能 二、硬件资源 三、程序编程 四、实现现象 一、主要功能 基于STC89C52单片机&#xff0c;采用dht11温湿度传感器检测温湿度&#xff0c; 通过lcd1602显示屏各个参数&#xff0c;四个按键分别可以增加温湿度的阈值&#xff0c; 如果超过阈值&#xff0c;则…
阅读更多...
SAP ABAP-日期格式问题 SAP内部错误,反序列化JSON字符串时发生异常 值 20241215 不是根据 ABAP 的 XML 格式的有效日期

SAP ABAP-日期格式问题 SAP内部错误,反序列化JSON字符串时发生异常 值 20241215 不是根据 ABAP 的 XML 格式的有效日期

SAP ABAP-日期格式问题 SAP内部错误,反序列化JSON字符串时发生异常 值 20241215 不是根据 ABAP 的 XML 格式的有效日期 在SAP内部用 YYYYMMDD没有问题 外部传入参数
阅读更多...
深度学习——激活函数、损失函数、优化器

深度学习——激活函数、损失函数、优化器

深度学习——激活函数、损失函数、优化器 1、激活函数1.1、一些常见的激活函数1.1.1、sigmoid1.1.2、softmax1.1.3、tanh1.1.4、ReLU1.1.5、Leaky ReLU1.1.6、PReLU1.1.7、GeLU1.1.8、ELU 1.2、激活函数的特点1.2.1、非线性1.2.2、几乎处处可微1.2.3、计算简单1.2.4、非饱和性1…
阅读更多...
YOLOv5-7.0训练过程中出现报错Example: export GIT_PYTHON_REFRESH=quiet

YOLOv5-7.0训练过程中出现报错Example: export GIT_PYTHON_REFRESH=quiet

出现报错&#xff1a; This initial message can be silenced or aggravated in the future by setting the $GIT_PYTHON_REFRESH environment variable. Use one of the following values: - quiet|q|silence|s|silent|none|n|0: for no message or exception - warn…
阅读更多...
发布/部署WebApi服务器(IIS+.NET8+ASP.NETCore)

发布/部署WebApi服务器(IIS+.NET8+ASP.NETCore)

CS软件授权注册系统-发布/部署WebApi服务器(IIS.NET8ASP.NETCore) 目录 本文摘要VS2022配置发布VS2022发布WebApiIIS服务器部署WebApi 将程序文件复制到云服务器添加网站配置应用程序池配置dns域名配置端口阿里云ECS服务器配置19980端口配置https协议 (申请ssl证书)测试WebAp…
阅读更多...
从零开始：如何在.NET Core Web API中完美配置Swagger文档

从零开始：如何在.NET Core Web API中完美配置Swagger文档

目录 新建项目 RestFul Swagger配置 注释展示 版本控制 Token传值 方法封装 新建项目 打开visual studio创建新项目&#xff0c;这里我们选择.net core web api模板&#xff0c;然后输入项目名称及其解决方案创建新项目 这里使用配置一些其他信息&#xff0c;根据自己情…
阅读更多...
零基础开始学习鸿蒙开发-基础页面的设计

零基础开始学习鸿蒙开发-基础页面的设计

目录 1.样例图 2.逐项分析 2.1 头顶布局分析&#xff1a;首先我们要把第一行的图标绘制出来&#xff0c;一个左一个右&#xff0c;很明显&#xff0c;需要放在一个Row容器中&#xff0c;具体代码如下&#xff1a; 2.2 和头像同一行的布局&#xff0c;需要注意的是&#xff0c…
阅读更多...
vscode借助插件调试OpenFoam的正确的.vscode配置文件

vscode借助插件调试OpenFoam的正确的.vscode配置文件

正确的备份文件位置&#xff1a; /home/jie/桌面/理解openfoam/正确的调试爆轰单进程案例/mydebugblastFoam 调试爆轰案例流体 并且工作区和用户区都是openfoam-7版本 问题&#xff1a;F5以debug模式启动后不停在断点 解决方法&#xff1a; 这里备份一下.vsode正确的配置&…
阅读更多...
【小白包会的】使用supervisor 管理docker内多进程

【小白包会的】使用supervisor 管理docker内多进程

使用supervisor 管理docker内多进程 一般情况下&#xff0c;一个docker是仅仅运行一个服务的 但是有的情况中&#xff0c;希望一个docker中运行多个进程&#xff0c;运行多个服务&#xff0c;也就是一个docker容器执行多个服务。 调研了一下&#xff0c;发现可以通过**super…
阅读更多...
day11 性能测试（3）——Jmeter 断言+关联

day11 性能测试（3）——Jmeter 断言+关联

【没有所谓的运气&#x1f36c;&#xff0c;只有绝对的努力✊】 目录 1、复习 2、查看结果树 多个http请求原因分析 3、作业 4、Jmeter断言 4.1 响应断言 4.1.1 案例 4.1.2 小结 4.2 json断言 4.2.1 案例 4.2.2 小结 4.3 断言持续时间 4.3.1 案例 4.3.2 小结 4.…
阅读更多...
热更新解决方案3 —— xLua

热更新解决方案3 —— xLua

概述 xLua框架导入和AB包相关准备 xLua导入 其它的导入 C#调用Lua 1.Lua解析器 using System.Collections; using System.Collections.Generic; using UnityEngine; //引用命名空间 using XLua;public class Lesson1_LuaEnv : MonoBehaviour {// Start is called before the fi…
阅读更多...
Rk3588 FFmpeg 拉流 RTSP, 硬解码转RGB

Rk3588 FFmpeg 拉流 RTSP, 硬解码转RGB

RK3588 ，基于FFmpeg, 拉取RTSP,使用 h264_rkmpp 实现硬解码. ⚡️ RK3588 编译ffmpeg参考: Ubuntu x64 架构, 交叉编译aarch64 FFmpeg mpp Code RTSPvoid hardwave_init(AVCo
阅读更多...
谷粒商城—分布式高级①.md

谷粒商城—分布式高级①.md

1. ELASTICSEARCH 1、安装elastic search dokcer中安装elastic search （1）下载ealastic search和kibana docker pull elasticsearch:7.6.2 docker pull kibana:7.6.2（2）配置 mkdir -p /mydata/elasticsearch/config mkdir -p /mydata/elasticsearch/data echo "h…
阅读更多...
OpenCV圆形标定板检测算法findGrid原理详解

OpenCV圆形标定板检测算法findGrid原理详解

OpenCV的findGrid函数检测圆形标定板的流程如下： class CirclesGridClusterFinder {CirclesGridClusterFinder(const CirclesGridClusterFinder&); public:CirclesGridClusterFinder
阅读更多...
30. Three.js案例-绘制并渲染圆弧

30. Three.js案例-绘制并渲染圆弧

30. Three.js案例-绘制并渲染圆弧 实现效果 知识点 WebGLRenderer WebGLRenderer 是 Three.js 中用于渲染 3D 场景的核心类。它利用 WebGL 技术在浏览器中渲染 3D 图形。 构造器 new THREE.WebGLRenderer(parameters) 参数类型描述parametersObject可选参数对象&#xff…
阅读更多...
STM32F407ZGT6-UCOSIII笔记4：时间片轮转调度

STM32F407ZGT6-UCOSIII笔记4：时间片轮转调度

本文学习与程序编写基于 正点原子的 STM32F1 UCOS开发手册 编写熟悉一下 UCOSIII系统的 时间片轮转调度 文章提供测试代码讲解、完整工程下载、测试效果图 目录 解决上文的卡系统问题&#xff1a; 使能时间片轮转调度&#xff1a; 任务初始化定义更改&#xff1a; 文件结构…
阅读更多...
谭浩强C++课后练习（更新中）

谭浩强C++课后练习（更新中）

基于过程的程序设计 第1章 C的初步知识 1. 请根据你的了解&#xff0c;叙述C的特点。C对C有哪些发展? 2. 一个 C程序是由哪几部分构成的?其中的每一部分起什么作用? 3. 从接到一个任务到得到最终结果&#xff0c;一般要经过几个步骤? 4. 请说明编辑、编译、连接的作用…
阅读更多...
单元测试知识总结

单元测试知识总结

我们希望每段代码都是自测试的&#xff0c;每次改动之后&#xff0c;都能自动发现对现有功能的影响。 1 测试要求 在对软件单元进行动态测试之前&#xff0c;应对软件单元的源代码进行静态测试&#xff1b; 应建立测试软件单元的环境&#xff0c;如数据准备、桩模块、模拟器…
阅读更多...
前后端跨域问题（CROS）

前后端跨域问题（CROS）

前端 在src中创建util文件&#xff0c;写request.js文件&#xff1a; request.js代码如下&#xff1a; import axios from axios import { ElMessage } from element-plus;const request axios.create({// baseURL: /api, // 注意&#xff01;&#xff01; 这里是全局统一加…
阅读更多...
【数据结构——查找】顺序查找（头歌实践教学平台习题）【合集】

【数据结构——查找】顺序查找（头歌实践教学平台习题）【合集】

目录&#x1f60b; 任务描述 相关知识 测试说明 我的通关代码: 测试结果&#xff1a; 任务描述 本关任务&#xff1a;实现顺序查找的算法。 相关知识 为了完成本关任务&#xff0c;你需要掌握&#xff1a;1.根据输入数据建立顺序表&#xff0c;2.顺序表的输出&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023