code: def _fused_adan_single_tensor(
      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,
      clip_global_grad_norm: Tensor,
  ):
      for i, param in enumerate(params):
          p_data_fp32 = param.data.float()
          out_p = param.data
          grad = grads[i]
          exp_avg = exp_avgs[i]
          exp_avg_sq = exp_avg_sqs[i]
          exp_avg_diff = exp_avg_diffs[i]
          neg_grad = neg_pre_grads[i]
          with torch.cuda.device(param.device):
              import fused_adan
  
              fused_adan.adan_single_tensor(
                  p_data_fp32,
                  out_p,
                  grad,
                  exp_avg,
                  exp_avg_sq,
                  exp_avg_diff,
                  neg_grad,
                  beta1,
                  beta2,
                  beta3,
                  bias_correction1,
                  bias_correction2,
                  bias_correction3_sqrt,
                  lr,
                  weight_decay,
                  eps,
                  no_prox,
                  clip_global_grad_norm,
              )
          neg_grad.zero_().add_(grad, alpha=-1.0)
  
file_path: NeMo/nemo/core/optim/adan.py
imports: import math
  from typing import List
  import torch
  from torch import Tensor
  from torch.optim.optimizer import Optimizer
label_desc: Use image node_id 4 for calling a global function with example usage: _fused_adan_single_tensor(params, grads, exp_avgs, exp_avg_sqs, exp_avg_diffs, neg_pre_grads) without return types