






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						)->						List[str]:
           __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						)->						Union[str, Any]:
           __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]						)








from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available





@dataclass
class       _lowerCAmelCase   (      __a			):
				_lowercase     						=42
				_lowercase     						=42


if is_transformers_available() and is_torch_available():
			from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline



