Add files using upload-large-folder tool

pytorch-image-models/timm/optim/_types.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict, Iterable, Union, Protocol, Type
+try:
+    from typing import TypeAlias, TypeVar
+except ImportError:
+    from typing_extensions import TypeAlias, TypeVar
+
+import torch
+import torch.optim
+
+try:
+    from torch.optim.optimizer import ParamsT
+except (ImportError, TypeError):
+    ParamsT: TypeAlias = Union[Iterable[torch.Tensor], Iterable[Dict[str, Any]]]
+
+
+OptimType = Type[torch.optim.Optimizer]
+
+
+class OptimizerCallable(Protocol):
+    """Protocol for optimizer constructor signatures."""
+
+    def __call__(self, params: ParamsT, **kwargs) -> torch.optim.Optimizer: ...
+
+
+__all__ = ['ParamsT', 'OptimType', 'OptimizerCallable']

pytorch-image-models/timm/optim/adafactor_bv.py

@@ -0,0 +1,320 @@
+""" Adafactor (Big Vision variant) for PyTorch
+
+Adapted from the implementation in big vision: https://github.com/google-research/big_vision
+
+Described in 'Scaling Vision Transformers': https://arxiv.org/abs/2106.04560
+
+Adaptation and PyTorch modifications by Ross Wightman
+"""
+from typing import List, Optional, Tuple, Union
+
+import torch
+from torch import Tensor
+from torch.optim import Optimizer
+
+from ._types import ParamsT
+
+
+def _get_scalar_dtype():
+    """Get the scalar dtype that the optimizer uses for state"""
+    return torch.float64
+
+
+def _factored_dims(
+        shape: Tuple[int, ...],
+        factored: bool,
+        min_dim_size_to_factor: int
+) -> Optional[tuple[int, int]]:
+    """Whether to use a factored second moment estimator.
+
+    This function returns a tuple with the two largest axes to reduce over.
+    If no two dimensions have size >= min_dim_size_to_factor, return None.
+
+    Args:
+      shape: an input shape
+      factored: whether to use factored second-moment estimator for > 2d vars.
+      min_dim_size_to_factor: only factor accumulator if two array dimensions have at least this size.
+
+    Returns:
+      None or a tuple of ints
+    """
+    if not factored or len(shape) < 2:
+        return None
+    sorted_dims = sorted(((x, i) for i, x in enumerate(shape)))
+    if shape[sorted_dims[-2][1]] < min_dim_size_to_factor:
+        return None
+    return int(sorted_dims[-2][1]), int(sorted_dims[-1][1])
+
+
+class AdafactorBigVision(Optimizer):
+    """
+    PyTorch implementation of BigVision's Adafactor variant with both single and multi tensor implementations.
+
+    Adapted from https://github.com/google-research/big_vision by Ross Wightman
+    """
+
+    def __init__(
+            self,
+            params: ParamsT,
+            lr: float = 1.0,
+            min_dim_size_to_factor: int = 16,
+            decay_rate: float = 0.8,
+            decay_offset: int = 0,
+            beta2_cap: float = 0.999,
+            momentum: Optional[float] = 0.9,
+            momentum_dtype: Union[str, torch.dtype] = torch.bfloat16,
+            eps: Optional[float] = None,
+            weight_decay: float = 0.0,
+            clipping_threshold: Optional[float] = None,
+            unscaled_wd: bool = False,
+            caution: bool = False,
+            *,
+            foreach: Optional[bool] = False,
+    ):
+        if isinstance(momentum_dtype, str):
+            if momentum_dtype == 'float16':
+                momentum_dtype = torch.float16
+            elif momentum_dtype == 'bfloat16':
+                momentum_dtype = torch.bfloat16
+            else:
+                assert momentum_dtype == 'float32', f'{momentum_dtype} dtype not supported'
+                momentum_dtype = torch.float32
+        # FIXME try to check if momentum dtype is appropriate for device? Torch API not great for this.
+
+        defaults = dict(
+            lr=lr,
+            min_dim_size_to_factor=min_dim_size_to_factor,
+            decay_rate=decay_rate,
+            decay_offset=decay_offset,
+            beta2_cap=beta2_cap,
+            momentum=momentum,
+            momentum_dtype=momentum_dtype,
+            eps=eps,
+            weight_decay=weight_decay,
+            clipping_threshold=clipping_threshold,
+            unscaled_wd=unscaled_wd,
+            caution=caution,
+            foreach=foreach,
+        )
+        super().__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super().__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('caution', False)
+            group.setdefault('foreach', None)
+            for p in group['params']:
+                p_state = self.state.get(p, {})
+                if len(p_state) != 0 and not torch.is_tensor(p_state['step']):
+                    p_state['step'] = torch.tensor(float(p_state['step']), dtype=_get_scalar_dtype())
+
+                if 'exp_avg' in p_state and torch.is_tensor(p_state['exp_avg']):
+                    # FIXME this is a bit of a hack, optimizer.load_state_dict appears to upcast
+                    # the momentum to float32 (it's half precision in the state_dict), need to
+                    # look into this further. Better to override _process_value_according_to_param_policy?
+                    p_state['exp_avg'] = p_state['exp_avg'].to(dtype=self.defaults['momentum_dtype'])
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = None
+        if closure is not None:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            params_with_grad = []
+            grads = []
+            exp_avg_sq_rs = []
+            exp_avg_sq_cs = []
+            exp_avg_sqs = []
+            state_steps = []
+            exp_avgs = []  # For momentum
+
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                if p.grad.is_sparse:
+                    raise RuntimeError("Sparse gradients not supported")
+
+                params_with_grad.append(p)
+                grads.append(p.grad)
+
+                state = self.state[p]
+
+                if len(state) == 0:
+                    # NOTE step on CPU, probably need some more though to make capturable
+                    state['step'] = torch.tensor(0.0, dtype=_get_scalar_dtype())
+
+                    shape = p.grad.shape
+                    factored_dims = _factored_dims(
+                        shape,
+                        factored=True,
+                        min_dim_size_to_factor=self.defaults['min_dim_size_to_factor']
+                    )
+
+                    if factored_dims is not None:
+                        dc, dr = factored_dims
+                        row_shape = list(p.grad.shape)
+                        row_shape[dr] = 1
+                        col_shape = list(p.grad.shape)
+                        col_shape[dc] = 1
+                        state['exp_avg_sq_r'] = p.grad.new_zeros(row_shape)
+                        state['exp_avg_sq_c'] = p.grad.new_zeros(col_shape)
+                    else:
+                        state['exp_avg_sq'] = torch.zeros_like(p.grad, memory_format=torch.preserve_format)
+
+                    if self.defaults['momentum'] is not None:
+                        state['exp_avg'] = torch.zeros_like(p.grad, dtype=self.defaults['momentum_dtype'])
+
+                state_steps.append(state['step'])
+                exp_avg_sq_rs.append(state.get('exp_avg_sq_r', None))
+                exp_avg_sq_cs.append(state.get('exp_avg_sq_c', None))
+                exp_avg_sqs.append(state.get('exp_avg_sq', None))
+                exp_avgs.append(state.get('exp_avg', None))
+
+            if group['foreach']:
+                func = _multi_tensor_adafactor
+            else:
+                func = _single_tensor_adafactor
+
+            func(
+                params=params_with_grad,
+                grads=grads,
+                exp_avg_sq_rs=exp_avg_sq_rs,
+                exp_avg_sq_cs=exp_avg_sq_cs,
+                exp_avg_sqs=exp_avg_sqs,
+                exp_avgs=exp_avgs,
+                state_steps=state_steps,
+                beta2_decay=group['decay_rate'],
+                beta2_cap=group['beta2_cap'],
+                min_dim_size_to_factor=group['min_dim_size_to_factor'],
+                eps=group['eps'],
+                lr=group['lr'],
+                weight_decay=group['weight_decay'],
+                momentum=group['momentum'],
+                momentum_dtype=group['momentum_dtype'],
+                clipping_threshold=group['clipping_threshold'],
+                unscaled_wd=group['unscaled_wd'],
+                caution=group['caution'],
+            )
+
+        return loss
+
+
+def _single_tensor_adafactor(
+        params: List[Tensor],
+        grads: List[Tensor],
+        exp_avg_sq_rs: List[Optional[Tensor]],
+        exp_avg_sq_cs: List[Optional[Tensor]],
+        exp_avg_sqs: List[Optional[Tensor]],
+        exp_avgs: List[Optional[Tensor]],
+        state_steps: List[Tensor],
+        *,
+        beta2_decay: float,
+        beta2_cap: float,
+        min_dim_size_to_factor: int,
+        eps: float,
+        lr: float,
+        weight_decay: float,
+        momentum: Optional[float],
+        momentum_dtype: Union[str, torch.dtype],
+        clipping_threshold: Optional[float],
+        unscaled_wd: bool,
+        caution: bool,
+):
+    for i, param in enumerate(params):
+        grad = grads[i]
+        exp_avg_sq_r = exp_avg_sq_rs[i]
+        exp_avg_sq_c = exp_avg_sq_cs[i]
+        exp_avg_sq = exp_avg_sqs[i]
+        exp_avg = exp_avgs[i]
+        step_t = state_steps[i]
+        if eps is None:
+            # default eps for avoiding div by zero, diff from float type eps
+            eps = 1e-7 if grad.dtype == torch.float16 else 1e-30
+
+        # Update step
+        step_t += 1
+        beta2_t = min(beta2_cap, 1.0 - float(step_t) ** (-beta2_decay))
+        one_minus_beta2_t = 1 - beta2_t
+
+        grad_sqr = torch.square(grad) + eps
+        # NOTE application of eps (epsilon1) mirrors the optax/big vision/t5x approach
+        if exp_avg_sq is None:
+            # factorized second moment
+            dc, dr = _factored_dims(grad.shape, True, min_dim_size_to_factor=min_dim_size_to_factor)
+            exp_avg_sq_r.lerp_(grad_sqr.mean(dim=dr, keepdim=True), one_minus_beta2_t)
+            exp_avg_sq_c.lerp_(grad_sqr.mean(dim=dc, keepdim=True), one_minus_beta2_t)
+
+            reduce_dc = dc - 1 if dc > dr else dc
+            row_col_mean = exp_avg_sq_r.mean(dim=reduce_dc, keepdim=True)
+            row_factor = (exp_avg_sq_r / row_col_mean).rsqrt()
+            col_factor = exp_avg_sq_c.rsqrt()
+
+            update = grad * row_factor * col_factor
+        else:
+            # non-factorized second moment
+            assert exp_avg_sq_r is None and exp_avg_sq_c is None
+            exp_avg_sq.lerp_(grad_sqr, one_minus_beta2_t)
+            update = grad * exp_avg_sq.rsqrt()
+
+        # Clip by RMS value
+        if clipping_threshold is not None:
+            denom = (update.norm(2) / ((update.numel() ** 0.5) / clipping_threshold)).clamp_(max=1.0)
+            update.div_(denom)
+
+        # Apply momentum (in different dtype)
+        if momentum is not None and exp_avg is not None:
+            if momentum_dtype != grad.dtype:
+                exp_avg.lerp_(update.to(momentum_dtype), 1 - momentum)  # ema
+                update = exp_avg.to(grad.dtype)
+            else:
+                exp_avg.lerp_(update, 1 - momentum)  # ema
+                update = exp_avg.clone()
+
+            if caution:
+                # apply caution as per 'Cautious Optimizers': https://arxiv.org/abs/2411.16085
+                mask = (update * grad > 0).to(grad.dtype)
+                mask.div_(mask.mean().clamp_(min=1e-3))
+                update.mul_(mask)
+
+        # Scale by learning rate
+        update.mul_(lr)
+
+        # Perform weight decay
+        if weight_decay != 0:
+            if unscaled_wd:
+                # match big vision impl, 'fully decoupled' decay w/o LR scaling
+                param.mul_(1. - weight_decay)
+            else:
+                # match typical pytorch behaviour for decoupled decay, eg adamw where wd is scaled by LR
+                param.mul_(1. - lr * weight_decay)
+
+        # Update parameters
+        param.add_(update, alpha=-1.0)
+
+
+def _multi_tensor_adafactor(
+        params: List[Tensor],
+        grads: List[Tensor],
+        exp_avg_sq_rs: List[Optional[Tensor]],
+        exp_avg_sq_cs: List[Optional[Tensor]],
+        exp_avg_sqs: List[Optional[Tensor]],
+        exp_avgs: List[Optional[Tensor]],
+        state_steps: List[Tensor],
+        *,
+        beta2_decay: float,
+        beta2_cap: float,
+        min_dim_size_to_factor: int,
+        eps: float,
+        lr: float,
+        weight_decay: float,
+        momentum: Optional[float],
+        momentum_dtype: Union[str, torch.dtype],
+        clipping_threshold: Optional[float],
+        unscaled_wd: bool,
+        caution: bool,
+):
+    # FIXME TODO
+    assert False, 'multi-tensor fn (foreach=True) not implemented yet'

pytorch-image-models/timm/optim/adamp.py

@@ -0,0 +1,120 @@
+"""
+AdamP Optimizer Implementation copied from https://github.com/clovaai/AdamP/blob/master/adamp/adamp.py
+
+Paper: `Slowing Down the Weight Norm Increase in Momentum-based Optimizers` - https://arxiv.org/abs/2006.08217
+Code: https://github.com/clovaai/AdamP
+
+Copyright (c) 2020-present NAVER Corp.
+MIT license
+"""
+
+import torch
+import torch.nn.functional as F
+from torch.optim.optimizer import Optimizer
+import math
+
+
+def _channel_view(x) -> torch.Tensor:
+    return x.reshape(x.size(0), -1)
+
+
+def _layer_view(x) -> torch.Tensor:
+    return x.reshape(1, -1)
+
+
+def projection(p, grad, perturb, delta: float, wd_ratio: float, eps: float):
+    wd = 1.
+    expand_size = (-1,) + (1,) * (len(p.shape) - 1)
+    for view_func in [_channel_view, _layer_view]:
+        param_view = view_func(p)
+        grad_view = view_func(grad)
+        cosine_sim = F.cosine_similarity(grad_view, param_view, dim=1, eps=eps).abs_()
+
+        # FIXME this is a problem for PyTorch XLA
+        if cosine_sim.max() < delta / math.sqrt(param_view.size(1)):
+            p_n = p / param_view.norm(p=2, dim=1).add_(eps).reshape(expand_size)
+            perturb -= p_n * view_func(p_n * perturb).sum(dim=1).reshape(expand_size)
+            wd = wd_ratio
+            return perturb, wd
+
+    return perturb, wd
+
+
+class AdamP(Optimizer):
+    def __init__(
+            self,
+            params,
+            lr=1e-3,
+            betas=(0.9, 0.999),
+            eps=1e-8,
+            weight_decay=0,
+            delta=0.1,
+            wd_ratio=0.1,
+            nesterov=False,
+    ):
+        defaults = dict(
+            lr=lr,
+            betas=betas,
+            eps=eps,
+            weight_decay=weight_decay,
+            delta=delta,
+            wd_ratio=wd_ratio,
+            nesterov=nesterov,
+        )
+        super(AdamP, self).__init__(params, defaults)
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = None
+        if closure is not None:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                beta1, beta2 = group['betas']
+                nesterov = group['nesterov']
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    state['exp_avg'] = torch.zeros_like(p)
+                    state['exp_avg_sq'] = torch.zeros_like(p)
+
+                # Adam
+                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
+
+                state['step'] += 1
+                bias_correction1 = 1 - beta1 ** state['step']
+                bias_correction2 = 1 - beta2 ** state['step']
+
+                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+
+                denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])
+                step_size = group['lr'] / bias_correction1
+
+                if nesterov:
+                    perturb = (beta1 * exp_avg + (1 - beta1) * grad) / denom
+                else:
+                    perturb = exp_avg / denom
+
+                # Projection
+                wd_ratio = 1.
+                if len(p.shape) > 1:
+                    perturb, wd_ratio = projection(p, grad, perturb, group['delta'], group['wd_ratio'], group['eps'])
+
+                # Weight decay
+                if group['weight_decay'] > 0:
+                    p.mul_(1. - group['lr'] * group['weight_decay'] * wd_ratio)
+
+                # Step
+                p.add_(perturb, alpha=-step_size)
+
+        return loss

pytorch-image-models/timm/optim/adamw.py

@@ -0,0 +1,140 @@
+""" AdamW Optimizer
+Impl copied from PyTorch master
+
+NOTE: This impl has been deprecated in favour of torch.optim.AdamW and remains as a reference
+"""
+import math
+from typing import Tuple
+
+import torch
+from torch.optim.optimizer import Optimizer
+
+from ._types import ParamsT
+
+
+class AdamWLegacy(Optimizer):
+    r"""Implements AdamW algorithm.
+
+    NOTE: This impl has been deprecated in favour of torch.optim.NAdam and remains as a reference
+
+    References:
+        - 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
+
+    Args:
+        params: iterable of parameters to optimize or dicts defining parameter groups
+        lr: learning rate
+        betas: coefficients used for computing running averages of gradient and its square
+        eps: term added to the denominator to improve numerical stability
+        weight_decay: weight decay coefficient
+        amsgrad: whether to use the AMSGrad variant of this algorithm
+            from the paper `On the Convergence of Adam and Beyond`
+        caution: apply caution when using AdamW
+    """
+
+    def __init__(
+            self,
+            params: ParamsT,
+            lr: float = 1e-3,
+            betas: Tuple[float, float] = (0.9, 0.999),
+            eps: float = 1e-8,
+            weight_decay: float = 1e-2,
+            amsgrad: bool = False,
+            caution: bool = 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,
+            caution=caution,
+        )
+        super(AdamWLegacy, self).__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super(AdamWLegacy, self).__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('amsgrad', False)
+            group.setdefault('caution', False)
+
+    @torch.no_grad()
+    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:
+            with torch.enable_grad():
+                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
+                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)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p)
+                    if amsgrad:
+                        # Maintains max of all exp. moving avg. of sq. grad. values
+                        state['max_exp_avg_sq'] = torch.zeros_like(p)
+
+                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
+                bias_correction1 = 1 - beta1 ** state['step']
+                bias_correction2 = 1 - beta2 ** state['step']
+
+                # Decay the first and second moment running average coefficient
+                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                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() / math.sqrt(bias_correction2)).add_(group['eps'])
+                else:
+                    denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])
+
+                step_size = group['lr'] / bias_correction1
+
+                if group['caution']:
+                    # Apply caution as per 'Cautious Optimizers' - https://arxiv.org/abs/2411.16085
+                    mask = (exp_avg * grad > 0).to(grad.dtype)
+                    mask.div_(mask.mean().clamp_(min=1e-3))
+                    exp_avg = exp_avg * mask
+
+                p.addcdiv_(exp_avg, denom, value=-step_size)
+
+        return loss

pytorch-image-models/timm/optim/adan.py

@@ -0,0 +1,295 @@
+""" Adan Optimizer
+
+Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models[J]. arXiv preprint arXiv:2208.06677, 2022.
+    https://arxiv.org/abs/2208.06677
+
+Implementation adapted from https://github.com/sail-sg/Adan
+"""
+# Copyright 2022 Garena Online Private Limited
+#
+# 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.
+
+import math
+from typing import List, Tuple
+
+import torch
+from torch import Tensor
+from torch.optim.optimizer import Optimizer
+
+
+class MultiTensorApply(object):
+    available = False
+    warned = False
+
+    def __init__(self, chunk_size):
+        try:
+            MultiTensorApply.available = True
+            self.chunk_size = chunk_size
+        except ImportError as err:
+            MultiTensorApply.available = False
+            MultiTensorApply.import_err = err
+
+    def __call__(self, op, noop_flag_buffer, tensor_lists, *args):
+        return op(self.chunk_size, noop_flag_buffer, tensor_lists, *args)
+
+
+class Adan(Optimizer):
+    """ Implements a pytorch variant of Adan.
+
+    Adan was proposed in Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models
+    https://arxiv.org/abs/2208.06677
+
+    Arguments:
+        params: Iterable of parameters to optimize or dicts defining parameter groups.
+        lr: Learning rate.
+        betas: Coefficients used for first- and second-order moments.
+        eps: Term added to the denominator to improve numerical stability.
+        weight_decay: Decoupled weight decay (L2 penalty)
+        no_prox: How to perform the weight decay
+        foreach: If True would use torch._foreach implementation. Faster but uses slightly more memory.
+    """
+
+    def __init__(self,
+            params,
+            lr: float = 1e-3,
+            betas: Tuple[float, float, float] = (0.98, 0.92, 0.99),
+            eps: float = 1e-8,
+            weight_decay: float = 0.0,
+            no_prox: bool = False,
+            foreach: bool = True,
+    ):
+        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]))
+        if not 0.0 <= betas[2] < 1.0:
+            raise ValueError('Invalid beta parameter at index 2: {}'.format(betas[2]))
+
+        defaults = dict(
+            lr=lr,
+            betas=betas,
+            eps=eps,
+            weight_decay=weight_decay,
+            no_prox=no_prox,
+            foreach=foreach,
+        )
+        super().__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super(Adan, self).__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('no_prox', False)
+
+    @torch.no_grad()
+    def restart_opt(self):
+        for group in self.param_groups:
+            group['step'] = 0
+            for p in group['params']:
+                if p.requires_grad:
+                    state = self.state[p]
+                    # State initialization
+
+                    # Exponential moving average of gradient values
+                    state['exp_avg'] = torch.zeros_like(p)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p)
+                    # Exponential moving average of gradient difference
+                    state['exp_avg_diff'] = torch.zeros_like(p)
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        """Performs a single optimization step."""
+        loss = None
+        if closure is not None:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            params_with_grad = []
+            grads = []
+            exp_avgs = []
+            exp_avg_sqs = []
+            exp_avg_diffs = []
+            neg_pre_grads = []
+
+            beta1, beta2, beta3 = group['betas']
+            # assume same step across group now to simplify things
+            # per parameter step can be easily supported by making it a tensor, or pass list into kernel
+            if 'step' in group:
+                group['step'] += 1
+            else:
+                group['step'] = 1
+
+            bias_correction1 = 1.0 - beta1 ** group['step']
+            bias_correction2 = 1.0 - beta2 ** group['step']
+            bias_correction3 = 1.0 - beta3 ** group['step']
+
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                params_with_grad.append(p)
+                grads.append(p.grad)
+
+                state = self.state[p]
+                if len(state) == 0:
+                    state['exp_avg'] = torch.zeros_like(p)
+                    state['exp_avg_sq'] = torch.zeros_like(p)
+                    state['exp_avg_diff'] = torch.zeros_like(p)
+
+                if 'neg_pre_grad' not in state or group['step'] == 1:
+                    state['neg_pre_grad'] = -p.grad.clone()
+
+                exp_avgs.append(state['exp_avg'])
+                exp_avg_sqs.append(state['exp_avg_sq'])
+                exp_avg_diffs.append(state['exp_avg_diff'])
+                neg_pre_grads.append(state['neg_pre_grad'])
+
+            if not params_with_grad:
+                continue
+
+            kwargs = dict(
+                params=params_with_grad,
+                grads=grads,
+                exp_avgs=exp_avgs,
+                exp_avg_sqs=exp_avg_sqs,
+                exp_avg_diffs=exp_avg_diffs,
+                neg_pre_grads=neg_pre_grads,
+                beta1=beta1,
+                beta2=beta2,
+                beta3=beta3,
+                bias_correction1=bias_correction1,
+                bias_correction2=bias_correction2,
+                bias_correction3_sqrt=math.sqrt(bias_correction3),
+                lr=group['lr'],
+                weight_decay=group['weight_decay'],
+                eps=group['eps'],
+                no_prox=group['no_prox'],
+            )
+
+            if group['foreach']:
+                _multi_tensor_adan(**kwargs)
+            else:
+                _single_tensor_adan(**kwargs)
+
+        return loss
+
+
+def _single_tensor_adan(
+        params: List[Tensor],
+        grads: List[Tensor],
+        exp_avgs: List[Tensor],
+        exp_avg_sqs: List[Tensor],
+        exp_avg_diffs: List[Tensor],
+        neg_pre_grads: List[Tensor],
+        *,
+        beta1: float,
+        beta2: float,
+        beta3: float,
+        bias_correction1: float,
+        bias_correction2: float,
+        bias_correction3_sqrt: float,
+        lr: float,
+        weight_decay: float,
+        eps: float,
+        no_prox: bool,
+):
+    for i, param in enumerate(params):
+        grad = grads[i]
+        exp_avg = exp_avgs[i]
+        exp_avg_sq = exp_avg_sqs[i]
+        exp_avg_diff = exp_avg_diffs[i]
+        neg_grad_or_diff = neg_pre_grads[i]
+
+        # for memory saving, we use `neg_grad_or_diff` to get some temp variable in an inplace way
+        neg_grad_or_diff.add_(grad)
+
+        exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)  # m_t
+        exp_avg_diff.mul_(beta2).add_(neg_grad_or_diff, alpha=1 - beta2)  # diff_t
+
+        neg_grad_or_diff.mul_(beta2).add_(grad)
+        exp_avg_sq.mul_(beta3).addcmul_(neg_grad_or_diff, neg_grad_or_diff, value=1 - beta3)  # n_t
+
+        denom = (exp_avg_sq.sqrt() / bias_correction3_sqrt).add_(eps)
+        step_size_diff = lr * beta2 / bias_correction2
+        step_size = lr / bias_correction1
+
+        if no_prox:
+            param.mul_(1 - lr * weight_decay)
+            param.addcdiv_(exp_avg, denom, value=-step_size)
+            param.addcdiv_(exp_avg_diff, denom, value=-step_size_diff)
+        else:
+            param.addcdiv_(exp_avg, denom, value=-step_size)
+            param.addcdiv_(exp_avg_diff, denom, value=-step_size_diff)
+            param.div_(1 + lr * weight_decay)
+
+        neg_grad_or_diff.zero_().add_(grad, alpha=-1.0)
+
+
+def _multi_tensor_adan(
+        params: List[Tensor],
+        grads: List[Tensor],
+        exp_avgs: List[Tensor],
+        exp_avg_sqs: List[Tensor],
+        exp_avg_diffs: List[Tensor],
+        neg_pre_grads: List[Tensor],
+        *,
+        beta1: float,
+        beta2: float,
+        beta3: float,
+        bias_correction1: float,
+        bias_correction2: float,
+        bias_correction3_sqrt: float,
+        lr: float,
+        weight_decay: float,
+        eps: float,
+        no_prox: bool,
+):
+    if len(params) == 0:
+        return
+
+    # for memory saving, we use `neg_pre_grads` to get some temp variable in a inplace way
+    torch._foreach_add_(neg_pre_grads, grads)
+
+    torch._foreach_mul_(exp_avgs, beta1)
+    torch._foreach_add_(exp_avgs, grads, alpha=1 - beta1)  # m_t
+
+    torch._foreach_mul_(exp_avg_diffs, beta2)
+    torch._foreach_add_(exp_avg_diffs, neg_pre_grads, alpha=1 - beta2)  # diff_t
+
+    torch._foreach_mul_(neg_pre_grads, beta2)
+    torch._foreach_add_(neg_pre_grads, grads)
+    torch._foreach_mul_(exp_avg_sqs, beta3)
+    torch._foreach_addcmul_(exp_avg_sqs, neg_pre_grads, neg_pre_grads, value=1 - beta3)  # n_t
+
+    denom = torch._foreach_sqrt(exp_avg_sqs)
+    torch._foreach_div_(denom, bias_correction3_sqrt)
+    torch._foreach_add_(denom, eps)
+
+    step_size_diff = lr * beta2 / bias_correction2
+    step_size = lr / bias_correction1
+
+    if no_prox:
+        torch._foreach_mul_(params, 1 - lr * weight_decay)
+        torch._foreach_addcdiv_(params, exp_avgs, denom, value=-step_size)
+        torch._foreach_addcdiv_(params, exp_avg_diffs, denom, value=-step_size_diff)
+    else:
+        torch._foreach_addcdiv_(params, exp_avgs, denom, value=-step_size)
+        torch._foreach_addcdiv_(params, exp_avg_diffs, denom, value=-step_size_diff)
+        torch._foreach_div_(params, 1 + lr * weight_decay)
+
+    torch._foreach_zero_(neg_pre_grads)
+    torch._foreach_add_(neg_pre_grads, grads, alpha=-1.0)

pytorch-image-models/timm/optim/lamb.py

@@ -0,0 +1,224 @@
+""" PyTorch Lamb optimizer w/ behaviour similar to NVIDIA FusedLamb
+
+This optimizer code was adapted from the following (starting with latest)
+* https://github.com/HabanaAI/Model-References/blob/2b435114fe8e31f159b1d3063b8280ae37af7423/PyTorch/nlp/bert/pretraining/lamb.py
+* https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py
+* https://github.com/cybertronai/pytorch-lamb
+
+Use FusedLamb if you can (GPU). The reason for including this variant of Lamb is to have a version that is
+similar in behaviour to APEX FusedLamb if you aren't using NVIDIA GPUs or cannot install/use APEX.
+
+In addition to some cleanup, this Lamb impl has been modified to support PyTorch XLA and has been tested on TPU.
+
+Original copyrights for above sources are below.
+
+Modifications Copyright 2021 Ross Wightman
+"""
+# Copyright (c) 2021, Habana Labs Ltd.  All rights reserved.
+
+# Copyright (c) 2019-2020, 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.
+
+# MIT License
+#
+# Copyright (c) 2019 cybertronai
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import math
+from typing import Optional, Tuple
+
+import torch
+from torch.optim import Optimizer
+
+from ._types import ParamsT
+
+
+class Lamb(Optimizer):
+    """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB
+    reference: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py
+
+    LAMB was proposed in:
+    - Large Batch Optimization for Deep Learning - Training BERT in 76 minutes:  https://arxiv.org/abs/1904.00962
+    - On the Convergence of Adam and Beyond: https://openreview.net/forum?id=ryQu7f-RZ
+
+    Args:
+        params: Iterable of parameters to optimize or dicts defining parameter groups.
+        lr: Learning rate
+        betas: Coefficients used for computing running averages of gradient and its norm.
+        eps: Term added to the denominator to improve numerical stability.
+        weight_decay: Weight decay
+        grad_averaging: Whether apply (1-beta2) to grad when calculating running averages of gradient.
+        max_grad_norm: Value used to clip global grad norm.
+        trust_clip: Enable LAMBC trust ratio clipping.
+        always_adapt: Apply adaptive learning rate to 0.0 weight decay parameter.
+        caution: Apply caution.
+    """
+
+    def __init__(
+            self,
+            params: ParamsT,
+            lr: float = 1e-3,
+            bias_correction: bool = True,
+            betas: Tuple[float, float] = (0.9, 0.999),
+            eps: float = 1e-6,
+            weight_decay: float = 0.01,
+            grad_averaging: bool = True,
+            max_grad_norm: Optional[float] = 1.0,
+            trust_clip: bool = False,
+            always_adapt: bool = False,
+            caution: bool = False,
+    ):
+        defaults = dict(
+            lr=lr,
+            bias_correction=bias_correction,
+            betas=betas,
+            eps=eps,
+            weight_decay=weight_decay,
+            grad_averaging=grad_averaging,
+            max_grad_norm=max_grad_norm,
+            trust_clip=trust_clip,
+            always_adapt=always_adapt,
+            caution=caution,
+        )
+        super().__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super().__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('caution', False)
+
+    def _get_clip_grad_norm(self):
+        max_grad_norm = self.defaults['max_grad_norm']
+        if max_grad_norm is None:
+            return None
+
+        norms = []
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad
+                if grad.is_sparse:
+                    raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instead.')
+                norms.append(torch.linalg.vector_norm(grad))
+        global_norm = torch.linalg.vector_norm(torch.stack(norms))
+        clip_global_norm = (global_norm / max_grad_norm).clamp_(min=1.0)
+        return clip_global_norm
+
+    @torch.no_grad()
+    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:
+            with torch.enable_grad():
+                loss = closure()
+
+        clip_grad_norm = self._get_clip_grad_norm() # None if disabled
+
+        for group in self.param_groups:
+            bias_correction = 1 if group['bias_correction'] else 0
+            beta1, beta2 = group['betas']
+            grad_averaging = 1 if group['grad_averaging'] else 0
+            beta3 = 1 - beta1 if grad_averaging else 1.0
+
+            # assume same step across group now to simplify things
+            # per parameter step can be easily support by making it tensor, or pass list into kernel
+            if 'step' in group:
+                group['step'] += 1
+            else:
+                group['step'] = 1
+
+            if bias_correction:
+                bias_correction1 = 1 - beta1 ** group['step']
+                bias_correction2 = 1 - beta2 ** group['step']
+            else:
+                bias_correction1, bias_correction2 = 1.0, 1.0
+
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad
+
+                if clip_grad_norm is not None:
+                    grad.div_(clip_grad_norm)
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    # Exponential moving average of gradient valuesa
+                    state['exp_avg'] = torch.zeros_like(p)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p)
+
+                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
+
+                # Decay the first and second moment running average coefficient
+                exp_avg.mul_(beta1).add_(grad, alpha=beta3)  # m_t
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)  # v_t
+
+                denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])
+                update = (exp_avg / bias_correction1).div_(denom)
+
+                if group['caution']:
+                    # Apply caution as per 'Cautious Optimizers' - https://arxiv.org/abs/2411.16085
+                    mask = (update * grad > 0).to(grad.dtype)
+                    mask.div_(mask.mean().clamp_(min=1e-3))
+                    update.mul_(mask)
+
+                weight_decay = group['weight_decay']
+                if weight_decay != 0:
+                    update.add_(p, alpha=weight_decay)
+
+                if weight_decay != 0 or group['always_adapt']:
+                    # Layer-wise LR adaptation. By default, skip adaptation on parameters that are
+                    # excluded from weight decay, unless always_adapt == True, then always enabled.
+                    w_norm = p.norm(2.0)
+                    g_norm = update.norm(2.0)
+                    trust_ratio = w_norm / g_norm
+                    # FIXME nested where required since logical and/or not working in PT XLA
+                    # Set the ratio to 1.0 (no change) if either weight norm or grad norm is zero
+                    trust_ratio = torch.where(
+                        w_norm > 0,
+                        torch.where(g_norm > 0, trust_ratio, 1.0),
+                        1.0,
+                    )
+                    if group['trust_clip']:
+                        # LAMBC trust clipping, upper bound fixed at one
+                        trust_ratio = torch.clamp(trust_ratio, max=1.0)
+                    update.mul_(trust_ratio)
+
+                p.add_(update, alpha=-group['lr'])
+
+        return loss

pytorch-image-models/timm/optim/nadam.py

@@ -0,0 +1,106 @@
+import math
+
+import torch
+from torch.optim.optimizer import Optimizer
+
+
+class NAdamLegacy(Optimizer):
+    """Implements Nadam algorithm (a variant of Adam based on Nesterov momentum).
+
+    NOTE: This impl has been deprecated in favour of torch.optim.NAdam and remains as a reference
+
+    It has been proposed in `Incorporating Nesterov Momentum into Adam`__.
+
+    Arguments:
+        params (iterable): iterable of parameters to optimize or dicts defining
+            parameter groups
+        lr (float, optional): learning rate (default: 2e-3)
+        betas (Tuple[float, float], optional): coefficients used for computing
+            running averages of gradient and its square
+        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)
+        schedule_decay (float, optional): momentum schedule decay (default: 4e-3)
+
+    __ http://cs229.stanford.edu/proj2015/054_report.pdf
+    __ http://www.cs.toronto.edu/~fritz/absps/momentum.pdf
+
+        Originally taken from: https://github.com/pytorch/pytorch/pull/1408
+        NOTE: Has potential issues but does work well on some problems.
+    """
+
+    def __init__(
+            self,
+            params,
+            lr=2e-3,
+            betas=(0.9, 0.999),
+            eps=1e-8,
+            weight_decay=0,
+            schedule_decay=4e-3,
+    ):
+        if not 0.0 <= lr:
+            raise ValueError("Invalid learning rate: {}".format(lr))
+        defaults = dict(
+            lr=lr,
+            betas=betas,
+            eps=eps,
+            weight_decay=weight_decay,
+            schedule_decay=schedule_decay,
+        )
+        super(NAdamLegacy, self).__init__(params, defaults)
+
+    @torch.no_grad()
+    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:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    state['m_schedule'] = 1.
+                    state['exp_avg'] = torch.zeros_like(p)
+                    state['exp_avg_sq'] = torch.zeros_like(p)
+
+                # Warming momentum schedule
+                m_schedule = state['m_schedule']
+                schedule_decay = group['schedule_decay']
+                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
+                beta1, beta2 = group['betas']
+                eps = group['eps']
+                state['step'] += 1
+                t = state['step']
+                bias_correction2 = 1 - beta2 ** t
+
+                if group['weight_decay'] != 0:
+                    grad = grad.add(p, alpha=group['weight_decay'])
+
+                momentum_cache_t = beta1 * (1. - 0.5 * (0.96 ** (t * schedule_decay)))
+                momentum_cache_t_1 = beta1 * (1. - 0.5 * (0.96 ** ((t + 1) * schedule_decay)))
+                m_schedule_new = m_schedule * momentum_cache_t
+                m_schedule_next = m_schedule * momentum_cache_t * momentum_cache_t_1
+                state['m_schedule'] = m_schedule_new
+
+                # Decay the first and second moment running average coefficient
+                exp_avg.mul_(beta1).add_(grad, alpha=1. - beta1)
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1. - beta2)
+
+                denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(eps)
+                p.addcdiv_(grad, denom, value=-group['lr'] * (1. - momentum_cache_t) / (1. - m_schedule_new))
+                p.addcdiv_(exp_avg, denom, value=-group['lr'] * momentum_cache_t_1 / (1. - m_schedule_next))
+
+        return loss

pytorch-image-models/timm/optim/rmsprop_tf.py

@@ -0,0 +1,169 @@
+""" RMSProp modified to behave like Tensorflow impl
+
+Originally cut & paste from PyTorch RMSProp
+https://github.com/pytorch/pytorch/blob/063946d2b3f3f1e953a2a3b54e0b34f1393de295/torch/optim/rmsprop.py
+Licensed under BSD-Clause 3 (ish), https://github.com/pytorch/pytorch/blob/master/LICENSE
+
+Modifications Copyright 2021 Ross Wightman
+"""
+
+import torch
+from torch.optim import Optimizer
+
+from ._types import ParamsT
+
+
+class RMSpropTF(Optimizer):
+    """Implements RMSprop algorithm (TensorFlow style epsilon)
+
+    NOTE: This is a direct cut-and-paste of PyTorch RMSprop with eps applied before sqrt
+    and a few other modifications to closer match Tensorflow for matching hyper-params.
+
+    Noteworthy changes include:
+    1. Epsilon applied inside square-root
+    2. square_avg initialized to ones
+    3. LR scaling of update accumulated in momentum buffer
+
+    Proposed by G. Hinton in his
+    `course <http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf>`_.
+
+    The centered version first appears in `Generating Sequences
+    With Recurrent Neural Networks <https://arxiv.org/pdf/1308.0850v5.pdf>`_.
+
+    Args:
+        params: iterable of parameters to optimize or dicts defining parameter groups
+        lr: learning rate
+        momentum: momentum factor
+        alpha: smoothing (decay) constant
+        eps: term added to the denominator to improve numerical stability
+        centered: if ``True``, compute the centered RMSProp, the gradient is normalized by an estimation of its variance
+        weight_decay: weight decay (L2 penalty) (default: 0)
+        decoupled_decay: decoupled weight decay as per https://arxiv.org/abs/1711.05101
+        lr_in_momentum: learning rate scaling is included in the momentum buffer update as per defaults in Tensorflow
+        caution: apply caution
+    """
+
+    def __init__(
+            self,
+            params: ParamsT,
+            lr: float = 1e-2,
+            alpha: float = 0.9,
+            eps: float = 1e-10,
+            weight_decay: float = 0,
+            momentum: float = 0.,
+            centered: bool = False,
+            decoupled_decay: bool = False,
+            lr_in_momentum: bool = True,
+            caution: bool = 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 <= momentum:
+            raise ValueError("Invalid momentum value: {}".format(momentum))
+        if not 0.0 <= weight_decay:
+            raise ValueError("Invalid weight_decay value: {}".format(weight_decay))
+        if not 0.0 <= alpha:
+            raise ValueError("Invalid alpha value: {}".format(alpha))
+
+        defaults = dict(
+            lr=lr,
+            momentum=momentum,
+            alpha=alpha,
+            eps=eps,
+            centered=centered,
+            weight_decay=weight_decay,
+            decoupled_decay=decoupled_decay,
+            lr_in_momentum=lr_in_momentum,
+            caution=caution,
+        )
+        super(RMSpropTF, self).__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super(RMSpropTF, self).__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('momentum', 0)
+            group.setdefault('centered', False)
+            group.setdefault('caution', False)
+
+    @torch.no_grad()
+    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:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad
+                if grad.is_sparse:
+                    raise RuntimeError('RMSprop does not support sparse gradients')
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    state['square_avg'] = torch.ones_like(p)  # PyTorch inits to zero
+                    if group['momentum'] > 0:
+                        state['momentum_buffer'] = torch.zeros_like(p)
+                    if group['centered']:
+                        state['grad_avg'] = torch.zeros_like(p)
+
+                square_avg = state['square_avg']
+                one_minus_alpha = 1. - group['alpha']
+
+                state['step'] += 1
+
+                if group['weight_decay'] != 0:
+                    if group['decoupled_decay']:
+                        p.mul_(1. - group['lr'] * group['weight_decay'])
+                    else:
+                        grad = grad.add(p, alpha=group['weight_decay'])
+
+                # Tensorflow order of ops for updating squared avg
+                square_avg.add_(grad.pow(2) - square_avg, alpha=one_minus_alpha)
+                # square_avg.mul_(alpha).addcmul_(grad, grad, value=1 - alpha)  # PyTorch original
+
+                if group['centered']:
+                    grad_avg = state['grad_avg']
+                    grad_avg.add_(grad - grad_avg, alpha=one_minus_alpha)
+                    avg = square_avg.addcmul(grad_avg, grad_avg, value=-1).add(group['eps']).sqrt_()  # eps in sqrt
+                    # grad_avg.mul_(alpha).add_(grad, alpha=1 - alpha)  # PyTorch original
+                else:
+                    avg = square_avg.add(group['eps']).sqrt_()  # eps moved in sqrt
+
+                if group['momentum'] > 0:
+                    buf = state['momentum_buffer']
+                    buf.mul_(group['momentum'])
+
+                    def _apply_caution(_m, _g):
+                        # Apply caution as per 'Cautious Optimizers' - https://arxiv.org/abs/2411.16085
+                        mask = (_m * _g > 0).to(_g.dtype)
+                        mask.div_(mask.mean().clamp_(min=1e-3))
+                        return _m * mask
+
+                    if group['lr_in_momentum']:
+                        # Tensorflow accumulates the LR scaling in the momentum buffer
+                        buf.addcdiv_(grad, avg, value=group['lr'])
+                        if group['caution']:
+                            buf = _apply_caution(buf, grad)
+                        p.add_(-buf)
+                    else:
+                        # PyTorch scales the param update by LR
+                        buf.addcdiv_(grad, avg)
+                        if group['caution']:
+                            buf = _apply_caution(buf, grad)
+                        p.add_(buf, alpha=-group['lr'])
+                else:
+                    p.addcdiv_(grad, avg, value=-group['lr'])
+
+        return loss

pytorch-image-models/timm/scheduler/__init__.py

@@ -0,0 +1,8 @@
+from .cosine_lr import CosineLRScheduler
+from .multistep_lr import MultiStepLRScheduler
+from .plateau_lr import PlateauLRScheduler
+from .poly_lr import PolyLRScheduler
+from .step_lr import StepLRScheduler
+from .tanh_lr import TanhLRScheduler
+
+from .scheduler_factory import create_scheduler, create_scheduler_v2, scheduler_kwargs