pytorch中的优化器optimizer.param_groups用法_Python

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

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

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

				?

									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)

				?

									[{'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}]

				?

									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)

				?

									[{'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}]

				?

									# 动态修改学习率

									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优化器为例：

				?

									# -*- 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），可能会造成损失函数在收敛过程中出现震荡。

如：

				?

									#调整学习率，新建一个optimizer

									old_lr=0.1

									optimizer=optim.SGD([

									                {'param':net.features.parameters()},

									                {'param':net.classifiers.parameters(),'lr':old_lr*0.5}],lr=1e-5)