class_docstr: Optimizer that implements the Adam algorithm.
  
  References:
    Adam - A Method for Stochastic Optimization:
      [Kingma et al., 2015](https://arxiv.org/abs/1412.6980)
      ([pdf](https://arxiv.org/pdf/1412.6980.pdf))
  
  @compatibility(TF2)
  tf.compat.v1.train.AdamOptimizer is compatible with eager mode and
  `tf.function`.
  When eager execution is enabled, `learning_rate`, `beta1`, `beta2`, and
  `epsilon` can each be a callable that takes no arguments and returns the
  actual value to use. This can be useful for changing these values across
  different invocations of optimizer functions.
  
  To switch to native TF2 style, use [`tf.keras.optimizers.Adam`]
  (https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam)
  instead. Please notice that due to the implementation differences,
  `tf.keras.optimizers.Adam` and
  `tf.compat.v1.train.AdamOptimizer` may have slight differences in
  floating point numerics even though the formula used for the variable
  updates still matches.
  
  #### Structural Mapping to Native TF2
  
  Before:
  
  ```python
  optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001)
  ```
  
  After:
  
  ```python
  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  ```
  
  #### How to Map Arguments
  |TF1 Arg Name          |TF2 Arg Name |Note                  |
  |----------------------|-------------|----------------------|
  |learning_rate         |learning_rate|Be careful of setting learning_rate as a
  :                      :             : tensor value computed from the global
  :                      :             : step. In TF1 this was usually meant to
  :                      :             : imply a dynamic learning rate and would
  :                      :             : recompute in each step. In TF2 (eager +
  :                      :             : function) it will treat it as a scalar
  :                      :             : value that only gets computed once
  :                      :             : instead of a symbolic placeholder to be
  :                      :             : computed each time.                   :
  |beta1                 |beta_1        |                      |
  |beta2                 |beta_2        |                      |
  |epsilon               |epsilon      | Default value is 1e-08 in TF1, but
  :                      :             : 1e-07 in TF2.                     :
  |use_locking           |N/A          |Not applicable in TF2. |
  
  #### Before & After Usage Example
  Before:
  
  ```python
  x = tf.Variable([1,2,3], dtype=tf.float32)
  grad = tf.constant([0.1, 0.2, 0.3])
  optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001)
  optimizer.apply_gradients(zip([grad], [x]))
  ```
  
  After:
  
  ```python
  x = tf.Variable([1,2,3], dtype=tf.float32)
  grad = tf.constant([0.1, 0.2, 0.3])
  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  optimizer.apply_gradients(zip([grad], [x]))
  ```
  
  @end_compatibility
code: def _resource_apply_sparse(self, grad, var, indices):
      return self._apply_sparse_shared(
          grad, var, indices, self._resource_scatter_add
      )
  
imports: from tensorflow.python.eager import context
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import control_flow_ops
  from tensorflow.python.ops import gen_training_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import resource_variable_ops
  from tensorflow.python.ops import state_ops
  from tensorflow.python.training import optimizer
  from tensorflow.python.util.tf_export import tf_export
label_desc: Use image node_id 10 for calling the AdamOptimizer obj's underlying member method code with example usage: obj._resource_apply_sparse(grad, var, indices) and returns: self