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



   """simple docstring"""





   def       snake_case						(				self:     Optional[Any]      ,a:     Any      ,a:     int      ,a:     int						):
    self.assertEqual(len(UpperCamelCase_						)      ,len(UpperCamelCase_						)						)
    for a, b in zip(UpperCamelCase_      ,UpperCamelCase_						):
     self.assertAlmostEqual(UpperCamelCase_      ,UpperCamelCase_      ,delta=UpperCamelCase_						)





   def       snake_case						(				self:     Tuple						):
    __UpperCAmelCase								=       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(UpperCamelCase_						):
     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:     List[Any]						):
    __UpperCAmelCase								=       None
    ops.enable_eager_execution_internal()
    __UpperCAmelCase								=       tf.config.list_physical_devices('CPU'						)
    if len(UpperCamelCase_						) == 1:
     tf.config.set_logical_device_configuration(
         physical_devices[0]      ,[tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]						)
    __UpperCAmelCase								=       tf.config.list_logical_devices(device_type='CPU'						)
    __UpperCAmelCase								=       tf.distribute.MirroredStrategy(devices=devices[:2]						)

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

    def accumulate_on_replica(a:     str						):
     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():
      __UpperCAmelCase								=       strategy.experimental_local_results(UpperCamelCase_						)
      local_variables[0].assign(UpperCamelCase_						)
      local_variables[1].assign(UpperCamelCase_						)
      strategy.run(UpperCamelCase_      ,args=(gradient_placeholder,)						)

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

    def _check_local_values(a:     List[Any]      ,a:     Optional[int]						):
     __UpperCAmelCase								=       strategy.experimental_local_results(accumulator._gradients[0]						)
     self.assertListAlmostEqual(values[0].value()      ,UpperCamelCase_      ,tol=1e-2						)
     self.assertListAlmostEqual(values[1].value()      ,UpperCamelCase_      ,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"""
from ..utils import DummyObject, requires_backends



class        UpperCamelCase__ (				metaclass=a_):







    """simple docstring"""
    __UpperCAmelCase           = ["""flax""", """transformers"""]







    def __init__(		self :	List[Any]				,    *UpperCamelCase_ :	str				,    **UpperCamelCase_ :	Any ):





           '''simple docstring'''

           requires_backends(self				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	Optional[int]				,    *UpperCamelCase_ :	Tuple				,    **UpperCamelCase_ :	List[Any] ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	str				,    *UpperCamelCase_ :	Optional[Any]				,    **UpperCamelCase_ :	Dict ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )



class        UpperCamelCase__ (				metaclass=a_):







    """simple docstring"""
    __UpperCAmelCase           = ["""flax""", """transformers"""]







    def __init__(		self :	List[Any]				,    *UpperCamelCase_ :	str				,    **UpperCamelCase_ :	str ):





           '''simple docstring'''

           requires_backends(self				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	Optional[int]				,    *UpperCamelCase_ :	Optional[int]				,    **UpperCamelCase_ :	List[str] ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	Tuple				,    *UpperCamelCase_ :	List[str]				,    **UpperCamelCase_ :	Optional[Any] ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )



class        UpperCamelCase__ (				metaclass=a_):







    """simple docstring"""
    __UpperCAmelCase           = ["""flax""", """transformers"""]







    def __init__(		self :	Optional[int]				,    *UpperCamelCase_ :	List[Any]				,    **UpperCamelCase_ :	List[str] ):





           '''simple docstring'''

           requires_backends(self				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	str				,    *UpperCamelCase_ :	List[str]				,    **UpperCamelCase_ :	Tuple ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	Tuple				,    *UpperCamelCase_ :	Any				,    **UpperCamelCase_ :	List[str] ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )



class        UpperCamelCase__ (				metaclass=a_):







    """simple docstring"""
    __UpperCAmelCase           = ["""flax""", """transformers"""]







    def __init__(		self :	Optional[Any]				,    *UpperCamelCase_ :	Optional[Any]				,    **UpperCamelCase_ :	Dict ):





           '''simple docstring'''

           requires_backends(self				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	str				,    *UpperCamelCase_ :	Dict				,    **UpperCamelCase_ :	List[str] ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )







    @classmethod
    def 				a__			(		cls :	str				,    *UpperCamelCase_ :	Optional[Any]				,    **UpperCamelCase_ :	Union[str, Any] ):





           '''simple docstring'''

           requires_backends(cls				,    ['flax', 'transformers'] )