class_docstr: Nesterov accelerated gradient.
  
  This optimizer updates each weight by::
  
      grad = clip(grad * rescale_grad, clip_gradient) + wd * weight
      state = momentum * state + lr * grad
      weight = weight - (momentum * state + lr * grad)
  
  Parameters
  ----------
  learning_rate : float, default 0.1
      The initial learning rate. If None, the optimization will use the
      learning rate from ``lr_scheduler``. If not None, it will overwrite
      the learning rate in ``lr_scheduler``. If None and ``lr_scheduler``
      is also None, then it will be set to 0.01 by default.
  momentum : float, default 0.9
     The momentum value.
  multi_precision: bool, default False
      Flag to control the internal precision of the optimizer.
      False: results in using the same precision as the weights (default),
      True: makes internal 32-bit copy of the weights and applies gradients
      in 32-bit precision even if actual weights used in the model have lower precision.
      Turning this on can improve convergence and accuracy when training with float16.
  use_fused_step : bool, default True
      Whether or not to use fused kernels for optimizer.
      When use_fused_step=False, step is called,
      otherwise, fused_step is called.
docstr: Perform an optimization step using gradients and states.
  
  Parameters
  ----------
  indices : list of int
      List of unique indices of the parameters into the individual learning rates
      and weight decays. Learning rates and weight decay may be set via `set_lr_mult()`
      and `set_wd_mult()`, respectively.
  weights : list of NDArray
      List of parameters to be updated.
  grads : list of NDArray
      List of gradients of the objective with respect to this parameter.
  states : List of any obj
      List of state returned by `create_state()`.
code: def step(self, indices, weights, grads, states):
      """Perform an optimization step using gradients and states.
  
      Parameters
      ----------
      indices : list of int
          List of unique indices of the parameters into the individual learning rates
          and weight decays. Learning rates and weight decay may be set via `set_lr_mult()`
          and `set_wd_mult()`, respectively.
      weights : list of NDArray
          List of parameters to be updated.
      grads : list of NDArray
          List of gradients of the objective with respect to this parameter.
      states : List of any obj
          List of state returned by `create_state()`.
      """
      for index, weight, grad, state in zip(
          indices, weights, grads, states
      ):
          self._update_count(index)
          lr = self._get_lr(index)
          wd = self._get_wd(index)
  
          # preprocess grad
          grad *= self.rescale_grad
          if self.clip_gradient is not None:
              grad = clip(grad, -self.clip_gradient, self.clip_gradient)
          grad += wd * weight
  
          # update mom
          mom = state
          if mom is not None:
              mom[:] *= self.momentum
              mom[:] -= lr * grad
              d = self.momentum * mom - lr * grad
          else:
              d = -lr * grad
  
          # update weight
          weight[:] += d
  
file_path: mxnet/python/mxnet/optimizer/nag.py
imports: from __future__ import absolute_import
  import numpy
  from ..ndarray import zeros, clip
  from ..ndarray import sgd_update, mp_sgd_update, nag_mom_update, mp_nag_mom_update
  from .optimizer import Optimizer, register
label_desc: Use image node_id 3 for calling the NAG obj's underlying member method code with example usage: obj.step(indices, weights, grads, states) without return types