





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  ):







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







  def 	UpperCAmelCase__		(	self						):
       lowerCAmelCase_					:       Any    =		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 	UpperCAmelCase__		(	self						):
       lowerCAmelCase_					:       str    =		None
       ops.enable_eager_execution_internal()
       lowerCAmelCase_					:       str    =		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_					:       List[str]    =		tf.config.list_logical_devices(device_type="""CPU"""						)
       lowerCAmelCase_					:       Union[str, Any]    =		tf.distribute.MirroredStrategy(devices=devices[:2]						)

       with strategy.scope():
            lowerCAmelCase_					:       Optional[int]    =		GradientAccumulator()
            lowerCAmelCase_					:       int    =		tf.Variable([4.0, 3.0]						)
            lowerCAmelCase_   ,  lowerCAmelCase_					:       str    =		create_optimizer(5e-5    ,						10    ,						5						)
            lowerCAmelCase_					:       Dict    =		tf.Variable([0.0, 0.0]    ,						trainable=_lowercase						)

       def accumulate_on_replica(_lowercase						):
            accumulator([gradient]						)

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

       @tf.function
       def accumulate(_lowercase    ,						_lowercase						):
            with strategy.scope():
                 lowerCAmelCase_					:       Union[str, Any]    =		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(_lowercase    ,						_lowercase						):
            lowerCAmelCase_					:       Optional[Any]    =		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]						)







from collections.abc import Sequence






def 							_lowerCAmelCase (  _a   :					Sequence[float]					,   _a   :					bool = False			)	->			float:
     if not arr:
          return 0

     lowerCAmelCase_					:       List[str]    =		0 if allow_empty_subarrays else float("""-inf"""			)
     lowerCAmelCase_					:       List[Any]    =		0.0
     for num in arr:
          lowerCAmelCase_					:       int    =		max(0 if allow_empty_subarrays else num					,   curr_sum + num			)
          lowerCAmelCase_					:       List[str]    =		max(_a					,   _a			)

     return max_sum


if __name__ == "__main__":
      from doctest import testmod

      testmod()

      UpperCAmelCase_					:   int 							=						[-2, 1, -3, 4, -1, 2, 1, -5, 4]
      print(F"""{max_subarray_sum(nums) = }""")
