'''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     a__      (   unittest.TestCase ):






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any  ,				a		:		Tuple  ,				a		:		Optional[int]  ,				a		:		Dict    ):





         """simple docstring"""



         self.assertEqual(len(lowercase_    )  ,				len(lowercase_    )    )
         for a, b in zip(lowercase_  ,				lowercase_    ):
             self.assertAlmostEqual(lowercase_  ,				lowercase_  ,				delta=lowercase_    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		int    ):





         """simple docstring"""



         __lowerCamelCase		=  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(lowercase_    ):
             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    SCREAMING_SNAKE_CASE__   ( self		:		Dict    ):





         """simple docstring"""



         __lowerCamelCase		=  None
         ops.enable_eager_execution_internal()
         __lowerCamelCase		=  tf.config.list_physical_devices('''CPU'''    )
         if len(lowercase_    ) == 1:
             tf.config.set_logical_device_configuration(
                 physical_devices[0]  ,				[tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]    )
         __lowerCamelCase		=  tf.config.list_logical_devices(device_type='''CPU'''    )
         __lowerCamelCase		=  tf.distribute.MirroredStrategy(devices=devices[:2]    )

         with strategy.scope():
             __lowerCamelCase		=  GradientAccumulator()
             __lowerCamelCase		=  tf.Variable([4.0, 3.0]    )
             __lowerCamelCase	,  __lowerCamelCase		=  create_optimizer(5e-5  ,				10  ,				5    )
             __lowerCamelCase		=  tf.Variable([0.0, 0.0]  ,				trainable=lowercase_    )

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

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

         @tf.function
         def accumulate(a		:		Dict  ,				a		:		Union[str, Any]    ):
             with strategy.scope():
                 __lowerCamelCase		=  strategy.experimental_local_results(lowercase_    )
                 local_variables[0].assign(lowercase_    )
                 local_variables[1].assign(lowercase_    )
                 strategy.run(lowercase_  ,				args=(gradient_placeholder,)    )

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

         def _check_local_values(a		:		Dict  ,				a		:		List[Any]    ):
             __lowerCamelCase		=  strategy.experimental_local_results(accumulator._gradients[0]    )
             self.assertListAlmostEqual(values[0].value()  ,				lowercase_  ,				tol=1e-2    )
             self.assertListAlmostEqual(values[1].value()  ,				lowercase_  ,				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]    )



def 			UpperCAmelCase__				(			):





  '''simple docstring'''







  return [
      a * b * (10_00 - a - b)
      for a in range(1	,      9_99							)
      for b in range(_A	,      9_99							)
      if (a * a + b * b == (10_00 - a - b) ** 2)
  ][0]


if __name__ == "__main__":
       print(f"""{solution() = }""")
