pytorch 优化器(optim)不同参数组,不同学习率设置的操作

cifiron = nn.MSELoss()
optimiter = torch.optim.SGD(net.parameters(),lr=0.01,momentum=0.9)
for i in range(iters):
    out = net(inputs)
    loss = cifiron(out,label)
    optimiter.zero_grad()  # 清空之前保留的梯度信息
    loss.backward()   # 将mini_batch 的loss 信息反传回去
 optimiter.step()  # 根据 optim参数 和 梯度 更新参数  w.data -= w.grad*lr

optimiter = torch.optim.Adam(net.parameters(),lr=0.01,momentum=0.9)

   optimizer = torch.optim.SGD([
            {'params': other_params}, 
            {'params': first_params, 'lr': 0.01*args.learning_rate},
            {'params': second_params, 'weight_decay': args.weight_decay}],
            lr=args.learning_rate,
            momentum=args.momentum,
    )

# 首先是 子类Adam 的构造函数
class Adam(Optimizer):
    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,
                 weight_decay=0, amsgrad=False):
        defaults = dict(lr=lr, betas=betas, eps=eps,
                        weight_decay=weight_decay, amsgrad=amsgrad)
        '''
        构造了 参数params，可以有两种传入格式,分别对应 
        1. 全局参数 net.parameters() 
        2. 不同参数组 [{'params': other_params}, 
                      {'params': first_params, 'lr': 0.1*lr}]
        和 <全局> 的默认参数字典defaults
        '''
        # 然后调用 父类Optimizer 的构造函数
        super(Adam, self).__init__(params, defaults)
        
# 看一下 Optim类的构造函数  只有两个输入 params 和 defaults
class Optimizer(object):
    def __init__(self, params, defaults):
        torch._C._log_api_usage_once("python.optimizer")
        self.defaults = defaults
		
        self.state = defaultdict(dict)
        self.param_groups = [] # 自身构造的参数组，每个组使用一套参数
		
        param_groups = list(params)
        if len(param_groups) == 0:
            raise ValueError("optimizer got an empty parameter list")
        # 如果传入的net.parameters()，将其转换为 字典
        if not isinstance(param_groups[0], dict):
            param_groups = [{'params': param_groups}]
		
        for param_group in param_groups:
        #add_param_group 这个函数,主要是处理一下每个参数组其它属性参数(lr,eps)
            self.add_param_group(param_group)
	def add_param_group(self, param_group):
        # 如果当前 参数组中 不存在默认参数的设置，则使用全局参数属性进行覆盖
        '''
        [{'params': other_params}, 
         {'params': first_params, 'lr': 0.1*lr}]
         如第一个参数组 只提供了参数列表，没有其它的参数属性，则使用全局属性覆盖，第二个参数组 则设置了自身的lr为全局 (0.1*lr)
        '''
        for name, default in self.defaults.items():
            if default is required and name not in param_group:
                raise ValueError("parameter group didn't specify a value of required optimization parameter " +
                                 name)
            else:
                param_group.setdefault(name, default)
		# 判断 是否有一个参数 出现在不同的参数组中，否则会报错
        param_set = set()
        for group in self.param_groups:
            param_set.update(set(group['params']))
        if not param_set.isdisjoint(set(param_group['params'])):
            raise ValueError("some parameters appear in more than one parameter group")
		# 然后 更新自身的参数组中
        self.param_groups.append(param_group)

def step(self, closure=None):
        loss = None
        if closure is not None:
            loss = closure()
        for group in self.param_groups:
        	# 本组参数更新所必需的 参数设置
            weight_decay = group['weight_decay']
            momentum = group['momentum']
            dampening = group['dampening']
            nesterov = group['nesterov']
            for p in group['params']:  # 本组所有需要更新的参数 params
                if p.grad is None:  # 如果没有梯度 则直接下一步
                    continue
                d_p = p.grad.data
                # 正则化 及 动量累积 操作
                if weight_decay != 0:
                    d_p.add_(weight_decay, p.data)
                if momentum != 0:
                    param_state = self.state[p]
                    if 'momentum_buffer' not in param_state:
                        buf = param_state['momentum_buffer'] = torch.clone(d_p).detach()
                    else:
                        buf = param_state['momentum_buffer']
                        buf.mul_(momentum).add_(1 - dampening, d_p)
                    if nesterov:
                        d_p = d_p.add(momentum, buf)
                    else:
                        d_p = buf
				# 当前组 学习参数 更新  w.data -= w.grad*lr
                p.data.add_(-group['lr'], d_p)
        return loss

    all_params = model.parameters()
    weight_params = []
    quant_params = []
    # 根据自己的筛选规则  将所有网络参数进行分组
    for pname, p in model.named_parameters():
        if any([pname.endswith(k) for k in ['cw', 'dw', 'cx', 'dx', 'lamb']]):
            quant_params += [p]
        elif ('conv' or 'fc' in pname and 'weight' in pname):
            weight_params += [p]    
	# 取回分组参数的id
    params_id = list(map(id, weight_params)) + list(map(id, quant_params))
    # 取回剩余分特殊处置参数的id
    other_params = list(filter(lambda p: id(p) not in params_id, all_params))
	# 构建不同学习参数的优化器
	optimizer = torch.optim.SGD([
            {'params': other_params}, 
            {'params': quant_params, 'lr': 0.1*args.learning_rate},
            {'params': weight_params, 'weight_decay': args.weight_decay}],
            lr=args.learning_rate,
            momentum=args.momentum,
    )

# # 以层为单位，为不同层指定不同的学习率
# ## 提取指定层对象
special_layers = t.nn.ModuleList([net.classifiter[0], net.classifiter[3]])
# ## 获取指定层参数id
special_layers_params = list(map(id, special_layers.parameters()))
print(special_layers_params)
# ## 获取非指定层的参数id
base_params = filter(lambda p: id(p) not in special_layers_params, net.parameters())
optimizer = t.optim.SGD([{'params': base_params},
                         {'params': special_layers.parameters(), 'lr': 0.01}], lr=0.001)

import re
str = 'assdffggggg'
word = 'a'
 a = [m.start() for m in re.finditer(word, str)]

for name, p in net.named_parameters():
for p in net.parameters():

word1 = 'seg'
for name, p in decode_net.named_parameters():
    str = name
    a = [m.start() for m in re.finditer(word1, str)]
    if a: #列表a不为空的话就设置回传的标识为False
        p.requires_grad = False
    else:
        p.requires_grad = True
    #if p.requires_grad:#这个判断可以打印出需要回传梯度的层的名称
        #print(name)

optimizer = optim.SGD(
            filter(lambda p: p.requires_grad, net.parameters()),  # 记住一定要加上filter()，不然会报错
            lr=0.01, weight_decay=1e-5, momentum=0.9)

base_params_id = list(map(id, net.conv1.parameters())) + list(map(id,net.bn1.parameters()))+\
 list(map(id,net.layer1.parameters())) + list(map(id,net.layer2.parameters())) \
  + list(map(id,net.layer3.parameters())) + list(map(id,net.layer4.parameters()))
new_params = filter(lambda p: id(p) not in base_params_id , net.parameters())
base_params = filter(lambda p: id(p) in base_params_id, net.parameters())

optimizerG = optim.SGD([{'params': base_params, 'lr': 1e-4}, 
                        {'params': new_params}], lr = opt.lr, momentum = 0.9, weight_decay=0.0005)

optimizerG = optim.SGD( filter(lambda p: p.requires_grad, net.parameters())，
      [{'params': base_params, 'lr': 1e-4}, 
                        {'params': new_params}], lr = opt.lr, momentum = 0.9, weight_decay=0.0005)

optimizerG = optim.SGD( filter(lambda p: p.requires_grad, net.parameters())，
      [{'params': base_params, 'lr': 1e-4}, 
                        {'params': new_params}], lr = opt.lr, momentum = 0.9, weight_decay=0.0005)

new_params = filter(lambda p: id(p) not in base_params_id and p.requires_grad,\
    netG.parameters())
base_params = filter(lambda p: id(p) in base_params_id,
                     netG.parameters())