class_docstr: Root mean squared propagation optimizer.
  
  The root mean square progation optimizer is a modified
  :class:`Adagrad optimizer <pennylane.optmimize.AdagradOptimizer>`,
  with a decay of learning rate adaptation.
  
  Extensions of the Adagrad optimization method generally
  start the sum :math:`a` over past gradients in the denominator
  of the learning rate at a finite :math:`t'` with :math:`0 < t' < t`,
  or decay past gradients to avoid an ever-decreasing learning rate.
  
  Root Mean Square propagation is such an adaptation, where
  
  .. math::
      a_i^{(t+1)} = \gamma a_i^{(t)} + (1-\gamma) (\partial_{x_i} f(x^{(t)}))^2.
  
  Args:
      stepsize (float): the user-defined hyperparameter :math:`\eta`
          used in the Adagrad optmization
      decay (float): the learning rate decay :math:`\gamma`
      eps (float): offset :math:`\epsilon` added for numerical stability
          (see :class:`Adagrad <pennylane.optmimize.AdagradOptimizer>`)
docstr: Update the variables args to take a single optimization step. Flattens and unflattens
  the inputs to maintain nested iterables as the parameters of the optimization.
  
  Args:
      grad (tuple [array]): the gradient of the objective function at
          point :math:`x^{(t)}`: :math:`\nabla f(x^{(t)})`.
      args (tuple): the current value of the variables :math:`x^{(t)}`.
  
  Returns:
      list [array]: the new values :math:`x^{(t+1)}`
docstr_tok: ["Update","the","variables","args","to","take","a","single","optimization","step",".","Flattens","and","unflattens","the","inputs","to","maintain","nested","iterables","as","the","parameters","of","the","optimization",".","Args",":","grad","(","tuple","[","array","]",")",":","the","gradient","of","the","objective","function","at","point",":","math",":","`","x^","{","(","t",")","}","`",":",":","math",":","`","\\nabla","f","(","x^","{","(","t",")","}",")","`",".","args","(","tuple",")",":","the","current","value","of","the","variables",":","math",":","`","x^","{","(","t",")","}","`",".","Returns",":","list","[","array","]",":","the","new","values",":","math",":","`","x^","{","(","t+1",")","}","`"]
code: def apply_grad(self, grad, args):
      r"""Update the variables args to take a single optimization step. Flattens and unflattens
      the inputs to maintain nested iterables as the parameters of the optimization.
  
      Args:
          grad (tuple [array]): the gradient of the objective function at
              point :math:`x^{(t)}`: :math:`\nabla f(x^{(t)})`.
          args (tuple): the current value of the variables :math:`x^{(t)}`.
  
      Returns:
          list [array]: the new values :math:`x^{(t+1)}`
      """
      args_new = list(args)
  
      if self.accumulation is None:
          self.accumulation = [0.0] * len(args)
  
      trained_index = 0
      for index, arg in enumerate(args):
          if getattr(arg, "requires_grad", False):
              self._update_accumulation(index, grad[trained_index])
              args_new[index] = (
                  arg
                  - (
                      self.stepsize
                      / sqrt(self.accumulation[index] + self.eps)
                  )
                  * grad[trained_index]
              )
              trained_index += 1
  
      return args_new
  
imports: from numpy import sqrt
  from .adagrad import AdagradOptimizer
label_desc: Use image node_id 2 for calling the RMSPropOptimizer obj's underlying member method code with example usage: obj.apply_grad(grad, args) and returns: args_new