class_docstr: Adagrad optimizer with row-wise learning rates.
  
  This class implements the AdaGrad optimizer described in *Adaptive
  Subgradient Methods for Online Learning and Stochastic Optimization*, and
  available at http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf but
  uses only a single learning rate for every row of the parameter array.
  
  This optimizer updates each weight by::
  
      grad = clip(grad * rescale_grad, clip_gradient)
      history += mean(square(grad), axis=1, keepdims=True)
      weight -= lr * grad / (sqrt(history) + epsilon)
  
  Weights are updated lazily if the gradient is sparse.
  
  For details of the update algorithm see
  :class:`~mxnet.ndarray.contrib.group_adagrad_update`.
  
  This optimizer accepts the following parameters in addition to those
  accepted by :class:`.Optimizer`. Weight decay is not supported.
  
  Parameters
  ----------
  learning_rate : float, default 0.01
      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.
  epsilon : float, default 1e-6
      Small value to avoid division by 0.
  use_fused_step : bool, default True
      Whether or not to use fused kernels for optimizer.
      When use_fused_step=False or grad is not sparse, step is called,
      otherwise, fused_step is called.
code: def __init__(
      self,
      learning_rate=0.01,
      epsilon=1e-6,
      use_fused_step=True,
      **kwargs,
  ):
      super(GroupAdaGrad, self).__init__(
          learning_rate=learning_rate,
          use_fused_step=use_fused_step,
          **kwargs,
      )
      self.epsilon = epsilon
  
imports: from ..ndarray import clip, contrib, mean, sqrt, square, zeros
  from .optimizer import Optimizer, register
label_desc: Use image node_id 1 to create a new GroupAdaGrad object from inherited base classes: Optimizer with example: obj = GroupAdaGrad(learning_rate, epsilon, use_fused_step)