class_docstr: Implements RMSprop algorithm (TensorFlow style epsilon)
  
  NOTE: This is a direct cut-and-paste of PyTorch RMSprop with eps applied before sqrt
  and a few other modifications to closer match Tensorflow for matching hyper-params.
  
  Noteworthy changes include:
  1. Epsilon applied inside square-root
  2. square_avg initialized to ones
  3. LR scaling of update accumulated in momentum buffer
  
  Proposed by G. Hinton in his
  `course <http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf>`_.
  
  The centered version first appears in `Generating Sequences
  With Recurrent Neural Networks <https://arxiv.org/pdf/1308.0850v5.pdf>`_.
  
  Arguments:
      params (iterable): iterable of parameters to optimize or dicts defining
          parameter groups
      lr (float, optional): learning rate (default: 1e-2)
      momentum (float, optional): momentum factor (default: 0)
      alpha (float, optional): smoothing (decay) constant (default: 0.9)
      eps (float, optional): term added to the denominator to improve
          numerical stability (default: 1e-10)
      centered (bool, optional) : if ``True``, compute the centered RMSProp,
          the gradient is normalized by an estimation of its variance
      weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
      decoupled_decay (bool, optional): decoupled weight decay as per https://arxiv.org/abs/1711.05101
      lr_in_momentum (bool, optional): learning rate scaling is included in the momentum buffer
          update as per defaults in Tensorflow
code: def __init__(
      self,
      params,
      lr=1e-2,
      alpha=0.9,
      eps=1e-10,
      weight_decay=0,
      momentum=0.0,
      centered=False,
      decoupled_decay=False,
      lr_in_momentum=True,
  ):
      if not 0.0 <= lr:
          raise ValueError("Invalid learning rate: {}".format(lr))
      if not 0.0 <= eps:
          raise ValueError("Invalid epsilon value: {}".format(eps))
      if not 0.0 <= momentum:
          raise ValueError(
              "Invalid momentum value: {}".format(momentum)
          )
      if not 0.0 <= weight_decay:
          raise ValueError(
              "Invalid weight_decay value: {}".format(weight_decay)
          )
      if not 0.0 <= alpha:
          raise ValueError("Invalid alpha value: {}".format(alpha))
  
      defaults = dict(
          lr=lr,
          momentum=momentum,
          alpha=alpha,
          eps=eps,
          centered=centered,
          weight_decay=weight_decay,
          decoupled_decay=decoupled_decay,
          lr_in_momentum=lr_in_momentum,
      )
      super(RMSpropTF, self).__init__(params, defaults)
  
imports: import torch
  from torch.optim import Optimizer
label_desc: Use image node_id 1 to create a new RMSpropTF object from inherited base classes: Optimizer with example: obj = RMSpropTF(params, lr, alpha, eps, weight_decay, momentum, centered, decoupled_decay, lr_in_momentum)