



"""simple docstring"""






import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
  import tensorflow as tf
  from tensorflow.python.eager import context
  from tensorflow.python.framework import ops

  from transformers import GradientAccumulator, create_optimizer

@require_tf
class 	__SCREAMING_SNAKE_CASE     (				unittest.TestCase       ):


     '''simple docstring'''





     def 		snake_case	(	self							:  Optional[Any],  lowerCamelCase							:  Optional[Any],  lowerCamelCase							:  int,  lowerCamelCase							:  Union[str, Any]					)-> Union[str, Any]:
        self.assertEqual(len(_A					),  len(_A					)					)
        for a, b in zip(_A,  _A					):
           self.assertAlmostEqual(_A,  _A,  delta=_A					)



     def 		snake_case	(	self							:  int					)-> int:
        lowerCamelCase__		:		Optional[int]		     =GradientAccumulator()
        accumulator([tf.constant([1.0, 2.0]					)]					)
        accumulator([tf.constant([-2.0, 1.0]					)]					)
        accumulator([tf.constant([-1.0, 2.0]					)]					)
        with self.assertRaises(_A					):
           accumulator([tf.constant([1.0, 1.0]					), tf.constant([2.0, 2.0]					)]					)
        self.assertEqual(accumulator.step,  3					)
        self.assertEqual(len(accumulator.gradients					),  1					)
        self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist(),  [-2.0, 5.0],  tol=1E-2					)
        accumulator.reset()
        self.assertEqual(accumulator.step,  0					)
        self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist(),  [0.0, 0.0],  tol=1E-2					)




     def 		snake_case	(	self							:  Optional[Any]					)-> Union[str, Any]:
        lowerCamelCase__		:		Any		     =None
        ops.enable_eager_execution_internal()
        lowerCamelCase__		:		Tuple		     =tf.config.list_physical_devices('''CPU'''					)
        if len(_A					) == 1:
           tf.config.set_logical_device_configuration(
               physical_devices[0],  [tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]					)
        lowerCamelCase__		:		Union[str, Any]		     =tf.config.list_logical_devices(device_type='''CPU'''					)
        lowerCamelCase__		:		Dict		     =tf.distribute.MirroredStrategy(devices=devices[:2]					)

        with strategy.scope():
           lowerCamelCase__		:		Dict		     =GradientAccumulator()
           lowerCamelCase__		:		Any		     =tf.Variable([4.0, 3.0]					)
           lowerCamelCase__		:		Dict		     =create_optimizer(5E-5,  10,  5					)
           lowerCamelCase__		:		Optional[int]		     =tf.Variable([0.0, 0.0],  trainable=_A					)

        def accumulate_on_replica(lowerCamelCase							:  Tuple					):
           accumulator([gradient]					)

        def apply_on_replica():
           optimizer.apply_gradients(list(zip(accumulator.gradients,  [variable]					)					)					)

        @tf.function
        def accumulate(lowerCamelCase							:  Optional[Any],  lowerCamelCase							:  Union[str, Any]					):
           with strategy.scope():
              lowerCamelCase__		:		Tuple		     =strategy.experimental_local_results(_A					)
              local_variables[0].assign(_A					)
              local_variables[1].assign(_A					)
              strategy.run(_A,  args=(gradient_placeholder,)					)

        @tf.function
        def apply_grad():
           with strategy.scope():
              strategy.run(_A					)

        def _check_local_values(lowerCamelCase							:  Tuple,  lowerCamelCase							:  List[Any]					):
           lowerCamelCase__		:		Optional[Any]		     =strategy.experimental_local_results(accumulator._gradients[0]					)
           self.assertListAlmostEqual(values[0].value(),  _A,  tol=1E-2					)
           self.assertListAlmostEqual(values[1].value(),  _A,  tol=1E-2					)

        accumulate([1.0, 2.0],  [-1.0, 1.0]					)
        accumulate([3.0, -1.0],  [-1.0, -1.0]					)
        accumulate([-2.0, 2.0],  [3.0, -2.0]					)
        self.assertEqual(accumulator.step,  3					)
        _check_local_values([2.0, 3.0],  [1.0, -2.0]					)
        apply_grad()
        self.assertListAlmostEqual(variable.value(),  [4.0, 3.0],  tol=1E-2					)
        accumulator.reset()
        self.assertEqual(accumulator.step,  0					)
        _check_local_values([0.0, 0.0],  [0.0, 0.0]					)









"""simple docstring"""






def 					snake_case__       (		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			return int((input_a, input_a).count(0     ) != 0     )






def 					snake_case__       (		):
			"""simple docstring"""
			assert nand_gate(0							,		0     ) == 1
			assert nand_gate(0							,		1     ) == 1
			assert nand_gate(1							,		0     ) == 1
			assert nand_gate(1							,		1     ) == 0


if __name__ == "__main__":
		print(nand_gate(0, 0))
		print(nand_gate(0, 1))
		print(nand_gate(1, 0))
		print(nand_gate(1, 1))




