class_docstr: The AdaDelta optimizer.
  
  This class implements AdaDelta, an optimizer described in  *ADADELTA: An adaptive
  learning rate method*, available at https://arxiv.org/abs/1212.5701.
  
  This optimizer updates each weight by::
  
      grad = clip(grad * rescale_grad, clip_gradient) + wd * weight
      acc_grad = rho * acc_grad + (1. - rho) * grad * grad
      delta = sqrt(acc_delta + epsilon) / sqrt(acc_grad + epsilon) * grad
      acc_delta = rho * acc_delta + (1. - rho) * delta * delta
      weight -= learning_rate * delta
  
  This optimizer accepts the following parameters in addition to those accepted
  by :class:`.Optimizer`.
  
  Parameters
  ----------
  learning_rate : float, default 1.0
      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.
  rho: float, default 0.9
      Decay rate for both squared gradients and delta.
  epsilon : float, default 1e-6
      Small value to avoid division by 0.
  use_fused_step : bool, default False
      Whether or not to use fused kernels for optimizer.
      When use_fused_step=False, step is called,
      otherwise, fused_step is called.
code: def create_state(self, index, weight):
      return (
          zeros(weight.shape, weight.context),  # accumulated g
          zeros(weight.shape, weight.context),
      )
  
imports: from __future__ import absolute_import
  from ..ndarray import zeros, clip, sqrt, square
  from .optimizer import Optimizer, register
label_desc: Use image node_id 2 for calling the AdaDelta obj's underlying member method code with example usage: obj.create_state(index, weight) and returns: zeros,  zeros