pytorch日积月累10-优化器

pytorch的优化器：管理并更新模型中可学习参数的值，使得模型输出更接近真实标签

导数：函数在指定坐标轴上的变化率

方向导数：指定方向上的变化率

梯度：一个向量，方向为方向导数取得最大值的方向

image-20200821163927532

1
2
3
4
5
6
class Optimizer(object):
    def __init__(self, params, defaults):
        self.defaults = defaults
        self.state = defaultdict(dict)
        self.param_groups = []
        param_groups = [{'params': param_groups}]

基本属性

  • defaults：优化器超参数
  • state：参数的缓存，如momentum的缓存
  • params_groups：管理的参数组
  • _step_count：记录更新次数，学习率调整中使用

基本方法：

zero_grad()：清空所管理参数的梯度

pytorch特性：张量梯度不自动清零

1
2
3
4
5
6
7
class Optimizer(object):
    def zero_grad(self):
        for group in self.param_groups:
            for p in group['params']:
                if p.grad is not None:
                    p.grad.detach_()
                    p.grad.zero_()

step()：执行一步更新

1
2
3
4
5
class Optimizer(object):
    def __init__(self, params, defaults):
        self.defaults = defaults
        self.state = defaultdict(dict)
        self.param_groups = []

add_param_group()：添加参数组

1
2
3
4
5
class Optimizer(object):
    def add_param_group(self, param_group):
        for group in self.param_groups:
            param_set.update(set(group['params’]))
            self.param_groups.append(param_group)

state_dict()：获取优化器当前状态信息字典

load_state_dict() ：加载状态信息字典

1
2
3
4
class Optimizer(object):
    def state_dict(self):
        return {'state': packed_state, 'param_groups': param_groups, }
    def load_state_dict(self, state_dict):
1
2
3
4
5
6
7
8
optimizer = optim.SGD([weight], lr=0.1, momentum=0.9)
opt_state_dict = optimizer.state_dict()
print("state_dict before step:\n", opt_state_dict)
for i in range(10):
    optimizer.step()
print("state_dict after step:\n", optimizer.state_dict())
torch.save(optimizer.state_dict(), os.path.join(BASE_DIR, 
                                                "optimizer_state_dict.pkl"))

学习率：

学习率（learning rate）控制更新的步伐。

Momentum（动量，冲量）：结合当前梯度与上一次更新信息，用于当前更新。

1
2
3
4
5
6
7
8
9
10
11
12
13
iter_rec, loss_rec, x_rec = list(), list(), list()
lr = 0.01    # /1. /.5 /.2 /.1 /.125
max_iteration = 20   # /1. 4     /.5 4   /.2 20 200
for i in range(max_iteration):
   y = func(x)
   y.backward()
   print("Iter:{}, X:{:8}, X.grad:{:8}, loss:{:10}".format(
           i, x.detach().numpy()[0], x.grad.detach().numpy()[0], y.item()))
   x_rec.append(x.item())
   x.data.sub_(lr * x.grad)    # x -= x.grad  数学表达式意义:  x = x - x.grad  
   x.grad.zero_()
   iter_rec.append(i)
   loss_rec.append(y)

指数加权平均：

1
2
3
4
def exp_w_func(beta, time_list):
    return [(1 - beta) * np.power(beta, exp) for exp in time_list]
 beta_list = [0.98, 0.95, 0.9, 0.8]
 w_list = [exp_w_func(beta, time_list) for beta in beta_list]

pytorch中参数更新的公式：

  • $w_{i+1}$是第i+1次更新的参数
  • $lr$：学习率
  • $v_i$：更新量
  • $m$：momentum参数
  • $g(w_i)$：$w_i$的梯度

optim.SGD

1
2
3
4
5
6
optim.SGD(params, #管理的参数组
          lr=<object object>,#初始学习率 
          momentum=0, #动量系数
          dampening=0, 
          weight_decay=0,#L2正则化系数 
          nesterov=False)#是否采用NAG

其他的优化器

  1. optim.SGD：随机梯度下降法
  2. optim.Adagrad：自适应学习率梯度下降法
  3. optim.RMSprop： Adagrad的改进
  4. optim.Adadelta： Adagrad的改进
  5. optim.Adam：RMSprop结合Momentum
  6. optim.Adamax：Adam增加学习率上限
  7. optim.SparseAdam：稀疏版的Adam
  8. optim.ASGD：随机平均梯度下降
  9. optim.Rprop：弹性反向传播
  10. optim.LBFGS：BFGS的改进