openpcdet中的优化器

OPTIMIZATION

优化器用于对梯度、学习率等进行调整
下面是一个优化器的配置：

OPTIMIZATION:
  BATCH_SIZE_PER_GPU: 4
  NUM_EPOCHS: 10

  OPTIMIZER: adam_onecycle
  LR: 0.001
  WEIGHT_DECAY: 0.04
  MOMENTUM: 0.8

  MOMS: [0.85, 0.75]
  PCT_START: 0.1
  DIV_FACTOR: 100
  DECAY_STEP_LIST: [35, 45]
  LR_DECAY: 0.1
  LR_CLIP: 0.0000001

  LR_WARMUP: False
  WARMUP_EPOCH: 1

  GRAD_NORM_CLIP: 10
  LOSS_SCALE_FP16: 32.0

下面来看每个配置的具体作用和含义：
按照配置的功能，可以分为以下几组：

• 首先是batch_size 和epoch

  BATCH_SIZE_PER_GPU: 4 # 表示每个GPU上一次迭代的batch size 是4
  NUM_EPOCHS: 10 # 表示一共训练10个epoch

• 然后是Optimizer（优化器）

  OPTIMIZER: adam_onecycle # 表示使用的优化器是adam_onecycle
  LR: 0.001 # 表示初始学习率是0.001
  WEIGHT_DECAY: 0.04 # 表示权重衰减系数是 0.04
  MOMENTUM: 0.8 # 表示MOMENTUM是0.8， SGD算法需要，其他不需要

• 然后是Scheduler（学习率调度器）

参考：https://blog.csdn.net/ChuiGeDaQiQiu/article/details/121462371
MOMS: [0.95, 0.85]
PCT_START: 0.1
DIV_FACTOR: 100
DECAY_STEP_LIST: [35, 45]
LR_DECAY: 0.1
LR_CLIP: 0.0000001
LR_WARMUP: False
WARMUP_EPOCH: 1

• 梯度裁剪clip_grad_norm_

GRAD_NORM_CLIP: 10
LOSS_SCALE_FP16: 32.0

下面对各个功能组件进行具体分析：
batch_size 和 epoch数比较简单，没啥好说的

下面来看Optimizer（优化器）

怎么构造

Optimizer在train.py中通过
build_optimizer(model, optim_cfg, filter_frozen_params=False) 函数进行构造

def build_optimizer(model, optim_cfg, filter_frozen_params=False):
    if optim_cfg.OPTIMIZER == 'adam':
        optimizer = optim.Adam(model.parameters(), lr=optim_cfg.LR, weight_decay=optim_cfg.WEIGHT_DECAY)
    elif optim_cfg.OPTIMIZER == 'sgd':
        optimizer = optim.SGD(
            model.parameters(), lr=optim_cfg.LR, weight_decay=optim_cfg.WEIGHT_DECAY,
            momentum=optim_cfg.MOMENTUM
        )
    elif optim_cfg.OPTIMIZER in ['adam_onecycle','adam_cosineanneal']:
        def children(m: nn.Module):
            return list(m.children())

        def num_children(m: nn.Module) -> int:
            return len(children(m))

        flatten_model = lambda m: sum(map(flatten_model, m.children()), []) if num_children(m) else [m]
        get_layer_groups = lambda m: [nn.Sequential(*flatten_model(m))]
        betas = optim_cfg.get('BETAS', (0.9, 0.99))
        betas = tuple(betas)
        optimizer_func = partial(optim.Adam, betas=betas)
        optimizer = OptimWrapper.create(
            optimizer_func, 3e-3, get_layer_groups(model), wd=optim_cfg.WEIGHT_DECAY, true_wd=True, bn_wd=True
        )
    else:
        raise NotImplementedError

    return optimizer

不同的Optimizer有不同的构造方法，openpcdet中提供了adam、sgd、adam_onecycle、adam_cosineanneal这几种Optimizer，这里不对Optimizer做具体解释，放在另外一个文档中进行具体分析

怎么使用

优化器的使用涉及到两方面：
一是使用优化器进行梯度更新
二是构造学习率调整器，由学习率调整器对优化器进行更新

首先来看使用优化器进行梯度更新

def train_one_epoch(..., optimizer, ...):
    ... 忽略一堆代码

    # 混合精度训练的缩放操作
    scaler = torch.cuda.amp.GradScaler(enabled=use_amp, init_scale=optim_cfg.get('LOSS_SCALE_FP16', 2.0 ** 16))
    
    ... 忽略一堆代码
    
    lr_scheduler.step(accumulated_iter, cur_epoch)  # 学习率调整
    try:
        cur_lr = float(optimizer.lr)    # 读取当前的学习率，用于日志显示
    except:
        cur_lr = optimizer.param_groups[0]['lr']

    if tb_log is not None:
        tb_log.add_scalar('meta_data/learning_rate', cur_lr, accumulated_iter)

    model.train()
    optimizer.zero_grad()      # 梯度清零

    with torch.cuda.amp.autocast(enabled=use_amp):
        loss, tb_dict, disp_dict = model_func(model, batch)

    scaler.scale(loss).backward()  # 如果不用混合精度训练，直接loss.backward()就行，进行方向传播计算
    scaler.unscale_(optimizer)     # 将优化器中的梯度反向缩放回原始的 FP32 精度
    clip_grad_norm_(model.parameters(), optim_cfg.GRAD_NORM_CLIP)   # 梯度裁剪，用于限制梯度的范数，防止梯度爆炸的情况发生
    scaler.step(optimizer)  # 使用优化器来更新模型的参数。由于之前已经对梯度进行了缩放处理，因此这里直接调用 step() 方法来执行参数更新
    scaler.update() # 用于更新 AMP 的内部状态，以便在下一次迭代中使用正确的缩放因子

    ... 忽略一堆代码

然后看构造学习率调整器

将上面构造好的optimizer作为参数传入 build_scheduler() 函数，用于构造学习率调整器
然后构造好的学习率调整器在每次迭代调用lr_scheduler.step(accumulated_iter, cur_epoch) 进行学习率调整

下面来看Scheduler（学习率调度器）

怎么构造

在build_scheduler() 函数中进行构造：

def build_scheduler(optimizer, total_iters_each_epoch, total_epochs, last_epoch, optim_cfg):
    decay_steps = [x * total_iters_each_epoch for x in optim_cfg.DECAY_STEP_LIST]
    def lr_lbmd(cur_epoch):
        cur_decay = 1
        for decay_step in decay_steps:
            if cur_epoch >= decay_step:
                cur_decay = cur_decay * optim_cfg.LR_DECAY
        return max(cur_decay, optim_cfg.LR_CLIP / optim_cfg.LR)

    lr_warmup_scheduler = None
    total_steps = total_iters_each_epoch * total_epochs
    if optim_cfg.OPTIMIZER == 'adam_onecycle':
        lr_scheduler = OneCycle(
            optimizer, total_steps, optim_cfg.LR, list(optim_cfg.MOMS), optim_cfg.DIV_FACTOR, optim_cfg.PCT_START
        )
    elif optim_cfg.OPTIMIZER == 'adam_cosineanneal':
        lr_scheduler = CosineAnnealing(
            optimizer, total_steps, total_epochs, optim_cfg.LR, list(optim_cfg.MOMS), optim_cfg.PCT_START, optim_cfg.WARMUP_ITER
        )
    else:
        lr_scheduler = lr_sched.LambdaLR(optimizer, lr_lbmd, last_epoch=last_epoch)

        if optim_cfg.LR_WARMUP:
            lr_warmup_scheduler = CosineWarmupLR(
                optimizer, T_max=optim_cfg.WARMUP_EPOCH * len(total_iters_each_epoch),
                eta_min=optim_cfg.LR / optim_cfg.DIV_FACTOR
            )

    return lr_scheduler, lr_warmup_scheduler

最后返回 lr_scheduler, lr_warmup_scheduler ， 分别是学习率调度器和学习率warmup调度器（LR_WARMUP=True时）

怎么使用

学习率调度器用法很简单：
只要在每次迭代中传入当前的迭代次数和当前的epoch数，调用step函数就可以更新学习率了
lr_scheduler.step(accumulated_iter, cur_epoch)

下面来看梯度裁剪

梯度裁剪使用比较简单：
调用函数就可以：
clip_grad_norm_(model.parameters(), optim_cfg.GRAD_NORM_CLIP)