optim.py

'''
Created on Feb 17, 2020

@author: Michal.Busta at gmail.com
'''

import math
import torch
from torch.optim.optimizer import Optimizer

class RAdam(Optimizer):

    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):
        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
        self.buffer = [[None, None, None] for ind in range(10)]
        super(RAdam, self).__init__(params, defaults)

    def __setstate__(self, state):
        super(RAdam, self).__setstate__(state)

    def step(self, closure=None):

        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.float()
                if grad.is_sparse:
                    raise RuntimeError('RAdam does not support sparse gradients')

                p_data_fp32 = p.data.float()

                state = self.state[p]

                if len(state) == 0:
                    state['step'] = 0
                    state['exp_avg'] = torch.zeros_like(p_data_fp32)
                    state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)
                else:
                    state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)
                    state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)

                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
                beta1, beta2 = group['betas']

                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
                exp_avg.mul_(beta1).add_(1 - beta1, grad)

                state['step'] += 1
                buffered = self.buffer[int(state['step'] % 10)]
                if state['step'] == buffered[0]:
                    N_sma, step_size = buffered[1], buffered[2]
                else:
                    buffered[0] = state['step']
                    beta2_t = beta2 ** state['step']
                    N_sma_max = 2 / (1 - beta2) - 1
                    N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)
                    buffered[1] = N_sma

                    # more conservative since it's an approximated value
                    if N_sma >= 5:
                        step_size = group['lr'] * math.sqrt((1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (N_sma_max - 2)) / (1 - beta1 ** state['step'])
                    else:
                        step_size = group['lr'] / (1 - beta1 ** state['step'])
                    buffered[2] = step_size

                if group['weight_decay'] != 0:
                    p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)

                # more conservative since it's an approximated value
                if N_sma >= 5:            
                    denom = exp_avg_sq.sqrt().add_(group['eps'])
                    p_data_fp32.addcdiv_(-step_size, exp_avg, denom)
                else:
                    p_data_fp32.add_(-step_size, exp_avg)

                p.data.copy_(p_data_fp32)

        return loss

class PlainRAdam(Optimizer):

    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):
        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)

        super(PlainRAdam, self).__init__(params, defaults)

    def __setstate__(self, state):
        super(PlainRAdam, self).__setstate__(state)

    def step(self, closure=None):

        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.float()
                if grad.is_sparse:
                    raise RuntimeError('RAdam does not support sparse gradients')

                p_data_fp32 = p.data.float()

                state = self.state[p]

                if len(state) == 0:
                    state['step'] = 0
                    state['exp_avg'] = torch.zeros_like(p_data_fp32)
                    state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)
                else:
                    state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)
                    state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)

                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
                beta1, beta2 = group['betas']

                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
                exp_avg.mul_(beta1).add_(1 - beta1, grad)

                state['step'] += 1
                beta2_t = beta2 ** state['step']
                N_sma_max = 2 / (1 - beta2) - 1
                N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)

                if group['weight_decay'] != 0:
                    p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)

                # more conservative since it's an approximated value
                if N_sma >= 5:                    
                    step_size = group['lr'] * math.sqrt((1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (N_sma_max - 2)) / (1 - beta1 ** state['step'])
                    denom = exp_avg_sq.sqrt().add_(group['eps'])
                    p_data_fp32.addcdiv_(-step_size, exp_avg, denom)
                else:
                    step_size = group['lr'] / (1 - beta1 ** state['step'])
                    p_data_fp32.add_(-step_size, exp_avg)

                p.data.copy_(p_data_fp32)

        return loss
    
    
# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

  
class Novograd(Optimizer):
  """
  Implements Novograd algorithm.
  Args:
      params (iterable): iterable of parameters to optimize or dicts defining
          parameter groups
      lr (float, optional): learning rate (default: 1e-3)
      betas (Tuple[float, float], optional): coefficients used for computing
          running averages of gradient and its square (default: (0.95, 0))
      eps (float, optional): term added to the denominator to improve
          numerical stability (default: 1e-8)
      weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
      grad_averaging: gradient averaging
      amsgrad (boolean, optional): whether to use the AMSGrad variant of this
          algorithm from the paper `On the Convergence of Adam and Beyond`_
          (default: False)
  """

  def __init__(self, params, lr=1e-3, betas=(0.95, 0), eps=1e-8,
               weight_decay=0, grad_averaging=False, amsgrad=False):
    if not 0.0 <= lr:
      raise ValueError("Invalid learning rate: {}".format(lr))
    if not 0.0 <= eps:
      raise ValueError("Invalid epsilon value: {}".format(eps))
    if not 0.0 <= betas[0] < 1.0:
      raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0]))
    if not 0.0 <= betas[1] < 1.0:
      raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1]))
    defaults = dict(lr=lr, betas=betas, eps=eps,
                  weight_decay=weight_decay,
                  grad_averaging=grad_averaging,
                  amsgrad=amsgrad)

    super(Novograd, self).__init__(params, defaults)

  def __setstate__(self, state):
    super(Novograd, self).__setstate__(state)
    for group in self.param_groups:
      group.setdefault('amsgrad', False)

  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.is_sparse:
          raise RuntimeError('Sparse gradients are not supported.')
        amsgrad = group['amsgrad']

        state = self.state[p]

        # State initialization
        if len(state) == 0:
          state['step'] = 0
          # Exponential moving average of gradient values
          state['exp_avg'] = torch.zeros_like(p.data)
          # Exponential moving average of squared gradient values
          state['exp_avg_sq'] = torch.zeros([]).to(state['exp_avg'].device)
          if amsgrad:
            # Maintains max of all exp. moving avg. of sq. grad. values
            state['max_exp_avg_sq'] = torch.zeros([]).to(state['exp_avg'].device)

        exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
        if amsgrad:
          max_exp_avg_sq = state['max_exp_avg_sq']
        beta1, beta2 = group['betas']

        state['step'] += 1

        norm = torch.sum(torch.pow(grad, 2))

        if exp_avg_sq == 0:
          exp_avg_sq.copy_(norm)
        else:
          exp_avg_sq.mul_(beta2).add_(1 - beta2, norm)

        if amsgrad:
          # Maintains the maximum of all 2nd moment running avg. till now
          torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)
          # Use the max. for normalizing running avg. of gradient
          denom = max_exp_avg_sq.sqrt().add_(group['eps'])
        else:
          denom = exp_avg_sq.sqrt().add_(group['eps'])

        grad.div_(denom)
        if group['weight_decay'] != 0:
          grad.add_(group['weight_decay'], p.data)
        if group['grad_averaging']:
          grad.mul_(1 - beta1)
        exp_avg.mul_(beta1).add_(grad)

        p.data.add_(-group['lr'], exp_avg)
    
    return loss
  

# Lookahead implementation from https://github.com/lonePatient/lookahead_pytorch/blob/master/optimizer.py

import itertools as it
from torch.optim import Optimizer, Adam

class Lookahead(Optimizer):
  def __init__(self, base_optimizer,alpha=0.5, k=6):
    if not 0.0 <= alpha <= 1.0:
      raise ValueError(f'Invalid slow update rate: {alpha}')
    if not 1 <= k:
      raise ValueError(f'Invalid lookahead steps: {k}')
    self.optimizer = base_optimizer
    self.param_groups = self.optimizer.param_groups
    self.alpha = alpha
    self.k = k
    for group in self.param_groups:
      group["step_counter"] = 0
    self.slow_weights = [[p.clone().detach() for p in group['params']]
                            for group in self.param_groups]

    for w in it.chain(*self.slow_weights):
      w.requires_grad = False
    self.state = base_optimizer.state
    self.defaults = self.optimizer.defaults

  def step(self, closure=None):
    loss = None
    if closure is not None:
      loss = closure()
    loss = self.optimizer.step()
    for group,slow_weights in zip(self.param_groups,self.slow_weights):
      group['step_counter'] += 1
      if group['step_counter'] % self.k != 0:
        continue
      for p,q in zip(group['params'],slow_weights):
        if p.grad is None:
          continue
        q.data.add_(self.alpha,p.data - q.data)
        p.data.copy_(q.data)
    return loss


def LookaheadAdam(params, alpha=0.5, k=6, *args, **kwargs):
  adam = Adam(params, *args, **kwargs)
  return Lookahead(adam, alpha, k)


import torch, math
from torch.optim.optimizer import Optimizer

# RAdam + LARS
class Ralamb(Optimizer):

  def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):
    defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
    self.buffer = [[None, None, None] for ind in range(10)]
    super(Ralamb, self).__init__(params, defaults)

  def __setstate__(self, state):
    super(Ralamb, self).__setstate__(state)

  def step(self, closure=None):

    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.float()
        if grad.is_sparse:
          raise RuntimeError('Ralamb does not support sparse gradients')

        p_data_fp32 = p.data.float()

        state = self.state[p]

        if len(state) == 0:
          state['step'] = 0
          state['exp_avg'] = torch.zeros_like(p_data_fp32)
          state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)
        else:
          state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)
          state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)

        exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
        beta1, beta2 = group['betas']

        # Decay the first and second moment running average coefficient
        # m_t
        exp_avg.mul_(beta1).add_(1 - beta1, grad)
        # v_t
        exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)

        state['step'] += 1
        buffered = self.buffer[int(state['step'] % 10)]

        if state['step'] == buffered[0]:
          N_sma, radam_step = buffered[1], buffered[2]
        else:
          buffered[0] = state['step']
          beta2_t = beta2 ** state['step']
          N_sma_max = 2 / (1 - beta2) - 1
          N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)
          buffered[1] = N_sma

          # more conservative since it's an approximated value
          if N_sma >= 5:
            radam_step = group['lr'] * math.sqrt((1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (N_sma_max - 2)) / (1 - beta1 ** state['step'])
          else:
            radam_step = group['lr'] / (1 - beta1 ** state['step'])
          buffered[2] = radam_step

        if group['weight_decay'] != 0:
            p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)

        weight_norm = p.data.pow(2).sum().sqrt().clamp(0, 10)
        radam_norm = p_data_fp32.pow(2).sum().sqrt()
        if weight_norm == 0 or radam_norm == 0:
          trust_ratio = 1
        else:
          trust_ratio = weight_norm / radam_norm

        state['weight_norm'] = weight_norm
        state['adam_norm'] = radam_norm
        state['trust_ratio'] = trust_ratio

        # more conservative since it's an approximated value
        if N_sma >= 5:
          denom = exp_avg_sq.sqrt().add_(group['eps'])
          p_data_fp32.addcdiv_(-radam_step * trust_ratio, exp_avg, denom)
        else:
          p_data_fp32.add_(-radam_step * trust_ratio, exp_avg)

        p.data.copy_(p_data_fp32)
    return loss
    

# RAdam + LARS + LookAHead

# Lookahead implementation from https://github.com/lonePatient/lookahead_pytorch/blob/master/optimizer.py
# RAdam + LARS implementation from https://gist.github.com/redknightlois/c4023d393eb8f92bb44b2ab582d7ec20

def Over9000(params, alpha=0.5, k=6, *args, **kwargs):
  ralamb = Ralamb(params, *args, **kwargs)
  return Lookahead(ralamb, alpha, k)

RangerLars = Over9000

class AdamW(Optimizer):
    r"""Implements AdamW algorithm.

    The original Adam algorithm was proposed in `Adam: A Method for Stochastic Optimization`_.
    The AdamW variant was proposed in `Decoupled Weight Decay Regularization`_.

    Arguments:
        params (iterable): iterable of parameters to optimize or dicts defining
            parameter groups
        lr (float, optional): learning rate (default: 1e-3)
        betas (Tuple[float, float], optional): coefficients used for computing
            running averages of gradient and its square (default: (0.9, 0.999))
        eps (float, optional): term added to the denominator to improve
            numerical stability (default: 1e-8)
        weight_decay (float, optional): weight decay coefficient (default: 1e-2)
        amsgrad (boolean, optional): whether to use the AMSGrad variant of this
            algorithm from the paper `On the Convergence of Adam and Beyond`_
            (default: False)

    .. _Adam\: A Method for Stochastic Optimization:
        https://arxiv.org/abs/1412.6980
    .. _Decoupled Weight Decay Regularization:
        https://arxiv.org/abs/1711.05101
    .. _On the Convergence of Adam and Beyond:
        https://openreview.net/forum?id=ryQu7f-RZ
    """

    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,
                 weight_decay=1e-2, amsgrad=False):
        if not 0.0 <= lr:
            raise ValueError("Invalid learning rate: {}".format(lr))
        if not 0.0 <= eps:
            raise ValueError("Invalid epsilon value: {}".format(eps))
        if not 0.0 <= betas[0] < 1.0:
            raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0]))
        if not 0.0 <= betas[1] < 1.0:
            raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1]))
        defaults = dict(lr=lr, betas=betas, eps=eps,
                        weight_decay=weight_decay, amsgrad=amsgrad)
        super(AdamW, self).__init__(params, defaults)

    def __setstate__(self, state):
        super(AdamW, self).__setstate__(state)
        for group in self.param_groups:
            group.setdefault('amsgrad', False)

    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

                # Perform stepweight decay
                p.data.mul_(1 - group['lr'] * group['weight_decay'])

                # Perform optimization step
                grad = p.grad.data
                if grad.is_sparse:
                    raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')
                amsgrad = group['amsgrad']

                state = self.state[p]

                # State initialization
                if len(state) == 0:
                    state['step'] = 0
                    # Exponential moving average of gradient values
                    state['exp_avg'] = torch.zeros_like(p.data)
                    # Exponential moving average of squared gradient values
                    state['exp_avg_sq'] = torch.zeros_like(p.data)
                    if amsgrad:
                        # Maintains max of all exp. moving avg. of sq. grad. values
                        state['max_exp_avg_sq'] = torch.zeros_like(p.data)

                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
                if amsgrad:
                    max_exp_avg_sq = state['max_exp_avg_sq']
                beta1, beta2 = group['betas']

                state['step'] += 1

                # Decay the first and second moment running average coefficient
                exp_avg.mul_(beta1).add_(1 - beta1, grad)
                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
                if amsgrad:
                    # Maintains the maximum of all 2nd moment running avg. till now
                    torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)
                    # Use the max. for normalizing running avg. of gradient
                    denom = max_exp_avg_sq.sqrt().add_(group['eps'])
                else:
                    denom = exp_avg_sq.sqrt().add_(group['eps'])

                bias_correction1 = 1 - beta1 ** state['step']
                bias_correction2 = 1 - beta2 ** state['step']
                step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1

                p.data.addcdiv_(-step_size, exp_avg, denom)

        return loss