class_docstr: RADam optimizer
      
class_docstr_tok: ["RADam","optimizer"]
docstr: step gradiend
docstr_tok: ["step","gradiend"]
code: def step(self, closure=None):
      """step gradiend"""
      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 = group["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
                  if n_sma >= 5:
                      step_size = 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"])
                  elif self.degenerated_to_sgd:
                      step_size = 1.0 / (1 - beta1 ** state["step"])
                  else:
                      step_size = -1
                  buffered[2] = step_size
              if n_sma >= 5:
                  if group["weight_decay"] != 0:
                      p_data_fp32.add_(
                          -group["weight_decay"] * group["lr"],
                          p_data_fp32,
                      )
                  denom = exp_avg_sq.sqrt().add_(group["eps"])
                  p_data_fp32.addcdiv_(
                      -step_size * group["lr"], exp_avg, denom
                  )
                  p.data.copy_(p_data_fp32)
              elif step_size > 0:
                  if group["weight_decay"] != 0:
                      p_data_fp32.add_(
                          -group["weight_decay"] * group["lr"],
                          p_data_fp32,
                      )
                  p_data_fp32.add_(-step_size * group["lr"], exp_avg)
                  p.data.copy_(p_data_fp32)
      return loss
  
file_path: gluon-cv/gluoncv/torch/utils/optimizer.py
imports: import math
  from enum import Enum
  import torch
  from torch.optim.optimizer import Optimizer
label_desc: Use image node_id 3 for calling the RAdam obj's underlying member method code with example usage: obj.step(closure) and returns: loss