def testScatterAdd(self):
     with self.test_session():
         handle = resource_variable_ops.var_handle_op(dtype=dtypes.int32, shape=[1, 1])
         resource_variable_ops.assign_variable_op(handle, constant_op.constant([[1]], dtype=dtypes.int32)).run()
         resource_variable_ops.resource_scatter_add(
             handle, [0], constant_op.constant([[2]], dtype=dtypes.int32)
         ).run()
         read = resource_variable_ops.read_variable_op(handle, dtype=dtypes.int32)
         self.assertEqual(read.eval(), [[3]])

 def _resource_apply_sparse_duplicate_indices(self, grad, var, indices, state):
   if self._use_momentum:
     return super(SGD, self)._resource_apply_sparse_duplicate_indices(
         grad, var, indices, state)
   else:
     lr = state.get_hyper("learning_rate", grad.dtype.base_dtype)
     return resource_variable_ops.resource_scatter_add(var.handle, indices,
                                                       -grad * lr)

 def _resource_apply_sparse_duplicate_indices(self, grad, var, indices):
   if self._momentum:
     return super(SGD, self)._resource_apply_sparse_duplicate_indices(
         grad, var, indices)
   else:
     return resource_variable_ops.resource_scatter_add(
         var.handle, indices, -grad * math_ops.cast(
             self._get_hyper("learning_rate"), grad.dtype.base_dtype))

 def testScatterAdd(self):
   handle = resource_variable_ops.var_handle_op(
       dtype=dtypes.int32, shape=[1, 1])
   self.evaluate(resource_variable_ops.assign_variable_op(
       handle, constant_op.constant([[1]], dtype=dtypes.int32)))
   self.evaluate(resource_variable_ops.resource_scatter_add(
       handle, [0], constant_op.constant([[2]], dtype=dtypes.int32)))
   read = resource_variable_ops.read_variable_op(handle, dtype=dtypes.int32)
   self.assertEqual(self.evaluate(read), [[3]])

 def _resource_apply_sparse_duplicate_indices(self, grad, var, indices):
   if self._momentum:
     return super(SGD, self)._resource_apply_sparse_duplicate_indices(
         grad, var, indices)
   else:
     var_dtype = var.dtype.base_dtype
     lr_t = self._decayed_lr(var_dtype)
     return resource_variable_ops.resource_scatter_add(var.handle, indices,
                                                       -grad * lr_t)

 def _assign_sub(self, ref, updates, indices=None):
   if indices is not None:
     if isinstance(ref, tf.Variable):
       return tf.scatter_sub(ref, indices, updates, use_locking=self._use_locking)
     elif isinstance(ref, resource_variable_ops.ResourceVariable):
       with tf.control_dependencies([resource_variable_ops.resource_scatter_add(ref.handle, indices, -updates)]):
         return ref.value()
     else:
       raise TypeError("did not expect type %r" % type(ref))
   else:
     return tf.assign_sub(ref, updates, use_locking=self._use_locking)

 def testScatterAddScalar(self):
   with self.test_session() as sess, self.test_scope():
     handle = resource_variable_ops.var_handle_op(
         dtype=dtypes.int32, shape=[1, 1])
     sess.run(
         resource_variable_ops.assign_variable_op(
             handle, constant_op.constant([[1]], dtype=dtypes.int32)))
     sess.run(
         resource_variable_ops.resource_scatter_add(
             handle, [0], constant_op.constant(2, dtype=dtypes.int32)))
     read = resource_variable_ops.read_variable_op(handle, dtype=dtypes.int32)
     self.assertEqual(self.evaluate(read), [[3]])

 def _resource_scatter_add(self, x, i, v):
   with ops.control_dependencies(
       [resource_variable_ops.resource_scatter_add(x.handle, i, v)]):
     return x.value()

 def _resource_apply_sparse_duplicate_indices(self, grad, handle, indices):
   return resource_variable_ops.resource_scatter_add(
       handle.handle, indices, -grad * self._learning_rate)

 def _resource_scatter_add(self, x, i, v, _=None):
   # last argument allows for one overflow argument, to have the same function
   # signature as state_ops.scatter_add
   with ops.control_dependencies(
       [resource_variable_ops.resource_scatter_add(x.handle, i, v)]):
     return x.value()

 def _resource_apply_sparse_duplicate_indices(
     self, grad, handle, indices, state):
   lr = state.get_hyper("learning_rate", grad.dtype.base_dtype)
   return resource_variable_ops.resource_scatter_add(
       handle.handle, indices, -grad * lr)