个人中心
gpt4 book ai didi

pytorch中的优化器optimizer.param_groups用法

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 30 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章pytorch中的优化器optimizer.param_groups用法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

optimizer.param_groups： 是长度为2的list，其中的元素是2个字典； 。

optimizer.param_groups[0]： 长度为6的字典，包括[‘amsgrad', ‘params', ‘lr', ‘betas', ‘weight_decay', ‘eps']这6个参数； 。

optimizer.param_groups[1]： 好像是表示优化器的状态的一个字典； 。

?
1
2
3
4
5
6
7
8
import torch
import torch.optim as optimh2
w1 = torch.randn( 3 , 3 )
w1.requires_grad = True
w2 = torch.randn( 3 , 3 )
w2.requires_grad = True
o = optim.Adam([w1])
print (o.param_groups)
?
1
2
3
4
5
6
7
8
[{ 'amsgrad' : False ,
   'betas' : ( 0.9 , 0.999 ),
   'eps' : 1e - 08 ,
   'lr' : 0.001 ,
   'params' : [tensor([[ 2.9064 , - 0.2141 , - 0.4037 ],
            [ - 0.5718 ,  1.0375 , - 0.6862 ],
            [ - 0.8372 ,  0.4380 , - 0.1572 ]])],
   'weight_decay' : 0 }]
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Per the docs, the add_param_group method accepts a param_group parameter that is a dict . Example of use:h2import torch
import torch.optim as optimh2
w1 = torch.randn( 3 , 3 )
w1.requires_grad = True
w2 = torch.randn( 3 , 3 )
w2.requires_grad = True
o = optim.Adam([w1])
print (o.param_groups)
givesh2[{ 'amsgrad' : False ,
   'betas' : ( 0.9 , 0.999 ),
   'eps' : 1e - 08 ,
   'lr' : 0.001 ,
   'params' : [tensor([[ 2.9064 , - 0.2141 , - 0.4037 ],
            [ - 0.5718 ,  1.0375 , - 0.6862 ],
            [ - 0.8372 ,  0.4380 , - 0.1572 ]])],
   'weight_decay' : 0 }]
nowh2o.add_param_group({ 'params' : w2})
print (o.param_groups)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[{ 'amsgrad' : False ,
   'betas' : ( 0.9 , 0.999 ),
   'eps' : 1e - 08 ,
   'lr' : 0.001 ,
   'params' : [tensor([[ 2.9064 , - 0.2141 , - 0.4037 ],
            [ - 0.5718 ,  1.0375 , - 0.6862 ],
            [ - 0.8372 ,  0.4380 , - 0.1572 ]])],
   'weight_decay' : 0 },
  { 'amsgrad' : False ,
   'betas' : ( 0.9 , 0.999 ),
   'eps' : 1e - 08 ,
   'lr' : 0.001 ,
   'params' : [tensor([[ - 0.0560 ,  0.4585 , - 0.7589 ],
            [ - 0.1994 ,  0.4557 ,  0.5648 ],
            [ - 0.1280 , - 0.0333 , - 1.1886 ]])],
   'weight_decay' : 0 }]
?
1
2
3
4
5
6
7
# 动态修改学习率
for param_group in optimizer.param_groups:
     param_group[ "lr" ] = lr
# 得到学习率optimizer.param_groups[0]["lr"] h2# print('查看optimizer.param_groups结构：')
# i_list=[i for i in optimizer.param_groups[0].keys()]
# print(i_list)   
[ 'amsgrad' , 'params' , 'lr' , 'betas' , 'weight_decay' , 'eps' ]

补充：pytorch中的优化器总结 。

以SGD优化器为例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# -*- coding: utf-8 -*-
#@Time    :2019/7/3 22:31
#@Author  :XiaoMa
 
from torch import nn as nn
import torch as t
from torch.autograd import Variable as V
#定义一个LeNet网络
class Net(nn.Module):
     def __init__( self ):
         super (Net, self ).__init__()
         self .features = nn.Sequential(
             nn.Conv2d( 3 , 6 , 5 ),
             nn.ReLU(),
             nn.MaxPool2d( 2 , 2 ),
             nn.Conv2d( 6 , 16 , 5 ),
             nn.ReLU(),
             nn.MaxPool2d( 2 , 3 )
         )
        
         self .classifier = nn.Sequential(\
             nn.Linear( 16 * 5 * 5 , 120 ),
             nn.ReLU(),
             nn.Linear( 120 , 84 ),
             nn.ReLU(),
             nn.Linear( 84 , 10 )
             )
     def forward( self , x):
         x = self .features(x)
         x = x.view( - 1 , 16 * 5 * 5 )
         x = self .classifier(x)
         return x
net = Net()
 
from torch import optim #优化器
optimizer = optim.SGD(params = net.parameters(),lr = 1 )
optimizer.zero_grad()   #梯度清零，相当于net.zero_grad()
 
input = V(t.randn( 1 , 3 , 32 , 32 ))
output = net( input )
output.backward(output)     #fake backward
optimizer.step()    #执行优化
 
#为不同子网络设置不同的学习率，在finetune中经常用到
#如果对某个参数不指定学习率，就使用默认学习率
optimizer = optim.SGD(
     [{ 'param' :net.features.parameters()},    #学习率为1e-5
     { 'param' :net.classifier.parameters(), 'lr' : 1e - 2 }],lr = 1e - 5
)
 
#只为两个全连接层设置较大的学习率，其余层的学习率较小
special_layers = nn.ModuleList([net.classifier[ 0 ],net.classifier[ 3 ]])
special_layers_params = list ( map ( id ,special_layers.parameters()))
base_params = filter ( lambda p: id (p) not in special_layers_params,net.parameters())
 
optimizer = t.optim.SGD([
     { 'param' :base_params},
     { 'param' :special_layers.parameters(), 'lr' : 0.01 }
],lr = 0.001 )

调整学习率主要有两种做法。

一种是修改optimizer.param_groups中对应的学习率，另一种是新建优化器（更简单也是更推荐的做法），由于optimizer十分轻量级，构建开销很小，故可以构建新的optimizer.

但是新建优化器会重新初始化动量等状态信息，这对使用动量的优化器来说（如自带的momentum的sgd），可能会造成损失函数在收敛过程中出现震荡.

如:

?
1
2
3
4
5
#调整学习率，新建一个optimizer
old_lr = 0.1
optimizer = optim.SGD([
                 { 'param' :net.features.parameters()},
                 { 'param' :net.classifiers.parameters(), 'lr' :old_lr * 0.5 }],lr = 1e - 5 )

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.

原文链接：https://wstchhwp.blog.csdn.net/article/details/108490956 。

最后此篇关于pytorch中的优化器optimizer.param_groups用法的文章就讲到这里了,如果你想了解更多关于pytorch中的优化器optimizer.param_groups用法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

30 4 0
文章推荐： 24款热门实用的jQuery插件推荐
文章推荐： nginx服务器的下载安装与使用详解
文章推荐： js获取当前时间显示在页面上并每秒刷新
文章推荐： 详解用Tomcat服务器配置https双向认证过程实战
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com