From 971d1802d009d9996b36a34a34477cee849ef39f Mon Sep 17 00:00:00 2001 From: Nikolai Yakovenko Date: Thu, 27 Aug 2020 04:58:13 -0400 Subject: [PATCH] Add AdaFactor optimizer from fairseq (#6722) * AdaFactor optimizer ported from fairseq. Tested for T5 finetuning and MLM -- reduced memory consumption compared to ADAM. * update PR fixes, add basic test * bug -- incorrect params in test * bugfix -- import Adafactor into test * bugfix -- removed accidental T5 include * resetting T5 to master * bugfix -- include Adafactor in __init__ * longer loop for adafactor test * remove double error class declare * lint * black * isort * Update src/transformers/optimization.py Co-authored-by: Sam Shleifer * single docstring * Cleanup docstring Co-authored-by: Nikolai Y Co-authored-by: Sam Shleifer --- src/transformers/__init__.py | 1 + src/transformers/optimization.py | 187 +++++++++++++++++++++++++++++++ tests/test_optimization.py | 26 +++++ 3 files changed, 214 insertions(+) diff --git a/src/transformers/__init__.py b/src/transformers/__init__.py index 1676ce5f66..9558fb457e 100755 --- a/src/transformers/__init__.py +++ b/src/transformers/__init__.py @@ -438,6 +438,7 @@ if is_torch_available(): # Optimization from .optimization import ( + Adafactor, AdamW, get_constant_schedule, get_constant_schedule_with_warmup, diff --git a/src/transformers/optimization.py b/src/transformers/optimization.py index 72c089efef..defafc51fd 100644 --- a/src/transformers/optimization.py +++ b/src/transformers/optimization.py @@ -316,3 +316,190 @@ class AdamW(Optimizer): p.data.add_(p.data, alpha=-group["lr"] * group["weight_decay"]) return loss + + +class Adafactor(Optimizer): + """ + AdaFactor pytorch implementation can be used as a drop in replacement for Adam + original fairseq code: https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py + + Paper: `Adafactor: Adaptive Learning Rates with Sublinear Memory Cost` https://arxiv.org/abs/1804.04235 + Note that this optimizer internally adjusts the learning rate depending on the *scale_parameter*, *relative_step* and + *warmup_init* options. To use a manual (external) learning rate schedule you should set `scale_parameter=False` and `relative_step=False`. + + Arguments: + params (iterable): iterable of parameters to optimize or dicts defining parameter groups + lr (float, optional): external learning rate (default: None) + eps (tuple[float, float]): regularization constants for square gradient + and parameter scale respectively (default: (1e-30, 1e-3)) + clip_threshold (float, default 1.0): threshold of root mean square of final gradient update + decay_rate (float, default: -0.8): coefficient used to compute running averages of square + beta1 (float): coefficient used for computing running averages of gradient + weight_decay (float, default=0): weight decay (L2 penalty) + scale_parameter (bool, default: True): if True, learning rate is scaled by root mean square of + relative_step (bool, default: True): if True, time-dependent learning rate is computed instead of external learning rate + warmup_init (bool, default: False): time-dependent learning rate computation depends on whether warm-up initialization is being used + + This implementation handles low-precision (FP16, bfloat) values, but we have not thoroughly tested. + + Recommended T5 finetuning settings: + scheduled LR warm-up to fixed LR, disable relative updates, use clip threshold: https://arxiv.org/abs/2004.14546 + Adafactor(model.parameters(), lr=1e-3, relative_step=False, warmup_init=True) + Alternatively, relative_step with warmup_init can be used. + Training without LR warmup or clip threshold, is not recommended. Additional optimizer operations like gradient clipping, should not be used alongside Adafactor. + + Usage:: + # replace AdamW with Adafactor + optimizer = Adafactor(model.parameters(), lr=1e-3, eps=(1e-30, 1e-3), clip_threshold=1.0, + decay_rate=-0.8, beta1=None, weight_decay=0.0, relative_step=False, + scale_parameter=False, warmup_init=False,) + """ + + def __init__( + self, + params, + lr=None, + eps=(1e-30, 1e-3), + clip_threshold=1.0, + decay_rate=-0.8, + beta1=None, + weight_decay=0.0, + scale_parameter=True, + relative_step=True, + warmup_init=False, + ): + if lr is not None and relative_step: + raise ValueError("Cannot combine manual lr and relative_step options") + if warmup_init and not relative_step: + raise ValueError("warmup_init requires relative_step=True") + + defaults = dict( + lr=lr, + eps=eps, + clip_threshold=clip_threshold, + decay_rate=decay_rate, + beta1=beta1, + weight_decay=weight_decay, + scale_parameter=scale_parameter, + relative_step=relative_step, + warmup_init=warmup_init, + ) + super().__init__(params, defaults) + + @staticmethod + def _get_lr(param_group, param_state): + rel_step_sz = param_group["lr"] + if param_group["relative_step"]: + min_step = 1e-6 * param_state["step"] if param_group["warmup_init"] else 1e-2 + rel_step_sz = min(min_step, 1.0 / math.sqrt(param_state["step"])) + param_scale = 1.0 + if param_group["scale_parameter"]: + param_scale = max(param_group["eps"][1], param_state["RMS"]) + return param_scale * rel_step_sz + + @staticmethod + def _get_options(param_group, param_shape): + factored = len(param_shape) >= 2 + use_first_moment = param_group["beta1"] is not None + return factored, use_first_moment + + @staticmethod + def _rms(tensor): + return tensor.norm(2) / (tensor.numel() ** 0.5) + + @staticmethod + def _approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col): + r_factor = (exp_avg_sq_row / exp_avg_sq_row.mean(dim=-1, keepdim=True)).rsqrt_() + c_factor = exp_avg_sq_col.rsqrt() + return torch.mm(r_factor.unsqueeze(-1), c_factor.unsqueeze(0)) + + def step(self, closure=None): + """Performs a single optimization step. + Arguments: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + if p.grad is None: + continue + grad = p.grad.data + if grad.dtype in {torch.float16, torch.bfloat16}: + grad = grad.float() + if grad.is_sparse: + raise RuntimeError("Adafactor does not support sparse gradients.") + + state = self.state[p] + grad_shape = grad.shape + + factored, use_first_moment = self._get_options(group, grad_shape) + # State Initialization + if len(state) == 0: + state["step"] = 0 + + if use_first_moment: + # Exponential moving average of gradient values + state["exp_avg"] = torch.zeros_like(grad) + if factored: + state["exp_avg_sq_row"] = torch.zeros(grad_shape[:-1]).to(grad) + state["exp_avg_sq_col"] = torch.zeros(grad_shape[:-2] + grad_shape[-1:]).to(grad) + else: + state["exp_avg_sq"] = torch.zeros_like(grad) + + state["RMS"] = 0 + else: + if use_first_moment: + state["exp_avg"] = state["exp_avg"].to(grad) + if factored: + state["exp_avg_sq_row"] = state["exp_avg_sq_row"].to(grad) + state["exp_avg_sq_col"] = state["exp_avg_sq_col"].to(grad) + else: + state["exp_avg_sq"] = state["exp_avg_sq"].to(grad) + + p_data_fp32 = p.data + if p.data.dtype in {torch.float16, torch.bfloat16}: + p_data_fp32 = p_data_fp32.float() + + state["step"] += 1 + state["RMS"] = self._rms(p_data_fp32) + group["lr"] = self._get_lr(group, state) + + beta2t = 1.0 - math.pow(state["step"], group["decay_rate"]) + update = (grad ** 2) + group["eps"][0] + if factored: + exp_avg_sq_row = state["exp_avg_sq_row"] + exp_avg_sq_col = state["exp_avg_sq_col"] + + exp_avg_sq_row.mul_(beta2t).add_(1.0 - beta2t, update.mean(dim=-1)) + exp_avg_sq_col.mul_(beta2t).add_(1.0 - beta2t, update.mean(dim=-2)) + + # Approximation of exponential moving average of square of gradient + update = self._approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col) + update.mul_(grad) + else: + exp_avg_sq = state["exp_avg_sq"] + + exp_avg_sq.mul_(beta2t).add_(1.0 - beta2t, update) + update = exp_avg_sq.rsqrt().mul_(grad) + + update.div_((self._rms(update) / group["clip_threshold"]).clamp_(min=1.0)) + update.mul_(group["lr"]) + + if use_first_moment: + exp_avg = state["exp_avg"] + exp_avg.mul_(group["beta1"]).add_(1 - group["beta1"], update) + update = exp_avg + + if group["weight_decay"] != 0: + p_data_fp32.add_(-group["weight_decay"] * group["lr"], p_data_fp32) + + p_data_fp32.add_(-update) + + if p.data.dtype in {torch.float16, torch.bfloat16}: + p.data.copy_(p_data_fp32) + + return loss diff --git a/tests/test_optimization.py b/tests/test_optimization.py index 5ab90dc0f5..54eff2ecdc 100644 --- a/tests/test_optimization.py +++ b/tests/test_optimization.py @@ -26,6 +26,7 @@ if is_torch_available(): import torch from transformers import ( + Adafactor, AdamW, get_constant_schedule, get_constant_schedule_with_warmup, @@ -80,6 +81,31 @@ class OptimizationTest(unittest.TestCase): w.grad.zero_() self.assertListAlmostEqual(w.tolist(), [0.4, 0.2, -0.5], tol=1e-2) + def test_adafactor(self): + w = torch.tensor([0.1, -0.2, -0.1], requires_grad=True) + target = torch.tensor([0.4, 0.2, -0.5]) + criterion = torch.nn.MSELoss() + # No warmup, constant schedule, no gradient clipping + optimizer = Adafactor( + params=[w], + lr=1e-2, + eps=(1e-30, 1e-3), + clip_threshold=1.0, + decay_rate=-0.8, + beta1=None, + weight_decay=0.0, + relative_step=False, + scale_parameter=False, + warmup_init=False, + ) + for _ in range(1000): + loss = criterion(w, target) + loss.backward() + optimizer.step() + w.grad.detach_() # No zero_grad() function on simple tensors. we do it ourselves. + w.grad.zero_() + self.assertListAlmostEqual(w.tolist(), [0.4, 0.2, -0.5], tol=1e-2) + @require_torch class ScheduleInitTest(unittest.TestCase):