






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


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)->	Dict:
           self.assertEqual(len(__UpperCamelCase	)					,						len(__UpperCamelCase	)	)
           for a, b in zip(__UpperCamelCase					,						__UpperCamelCase	):
                self.assertAlmostEqual(__UpperCamelCase					,						__UpperCamelCase					,						delta=__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	int:
           __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(__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  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					None
           ops.enable_eager_execution_internal()
           __lowerCAmelCase								=					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()]	)
           __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					,						1_0					,						5	)
                __lowerCAmelCase								=					tf.Variable([0.0, 0.0]					,						trainable=__UpperCamelCase	)

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

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

           @tf.function
           def accumulate(__UpperCamelCase					,						__UpperCamelCase	):
                with strategy.scope():
                     __lowerCAmelCase								=					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(__UpperCamelCase					,						__UpperCamelCase	):
                __lowerCAmelCase								=					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]	)














import os
import sys
import unittest


lowerCamelCase			:					int         =	os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
lowerCamelCase			:					Any         =	os.path.join(git_repo_path, '''src''', '''diffusers''')



class 							_UpperCamelCase			(unittest.TestCase			):


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					find_backend("    if not is_torch_available():"	)
           self.assertEqual(__UpperCamelCase					,						"torch"	)

           # backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
           # self.assertEqual(backend_with_underscore, "tensorflow_text")

           __lowerCAmelCase								=					find_backend("    if not (is_torch_available() and is_transformers_available()):"	)
           self.assertEqual(__UpperCamelCase					,						"torch_and_transformers"	)

           # double_backend_with_underscore = find_backend(
           #    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
           # )
           # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

           __lowerCAmelCase								=					find_backend(
               "    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):"	)
           self.assertEqual(__UpperCamelCase					,						"torch_and_transformers_and_onnx"	)


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					read_init()
           # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
           self.assertIn("torch"					,						__UpperCamelCase	)
           self.assertIn("torch_and_transformers"					,						__UpperCamelCase	)
           self.assertIn("flax_and_transformers"					,						__UpperCamelCase	)
           self.assertIn("torch_and_transformers_and_onnx"					,						__UpperCamelCase	)

           # Likewise, we can't assert on the exact content of a key
           self.assertIn("UNet2DModel"					,						objects["torch"]	)
           self.assertIn("FlaxUNet2DConditionModel"					,						objects["flax"]	)
           self.assertIn("StableDiffusionPipeline"					,						objects["torch_and_transformers"]	)
           self.assertIn("FlaxStableDiffusionPipeline"					,						objects["flax_and_transformers"]	)
           self.assertIn("LMSDiscreteScheduler"					,						objects["torch_and_scipy"]	)
           self.assertIn("OnnxStableDiffusionPipeline"					,						objects["torch_and_transformers_and_onnx"]	)


      def  __UpperCAmelCase		(	self	)->	Any:
           __lowerCAmelCase								=					create_dummy_object("CONSTANT"					,						"'torch'"	)
           self.assertEqual(__UpperCamelCase					,						"\nCONSTANT = None\n"	)

           __lowerCAmelCase								=					create_dummy_object("function"					,						"'torch'"	)
           self.assertEqual(
               __UpperCamelCase					,						"\ndef function(*args, **kwargs):\n    requires_backends(function, 'torch')\n"	)

           __lowerCAmelCase								=					"\nclass FakeClass(metaclass=DummyObject):\n    _backends = 'torch'\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, 'torch')\n\n    @classmethod\n    def from_config(cls, *args, **kwargs):\n        requires_backends(cls, 'torch')\n\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        requires_backends(cls, 'torch')\n"
           __lowerCAmelCase								=					create_dummy_object("FakeClass"					,						"'torch'"	)
           self.assertEqual(__UpperCamelCase					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Tuple:
           __lowerCAmelCase								=					"# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n    requires_backends(function, [\"torch\"])\n\n\nclass FakeClass(metaclass=DummyObject):\n    _backends = [\"torch\"]\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, [\"torch\"])\n\n    @classmethod\n    def from_config(cls, *args, **kwargs):\n        requires_backends(cls, [\"torch\"])\n\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        requires_backends(cls, [\"torch\"])\n"
           __lowerCAmelCase								=					create_dummy_files({"torch": ["CONSTANT", "function", "FakeClass"]}	)
           self.assertEqual(dummy_files["torch"]					,						__UpperCamelCase	)






