



'''simple docstring'''





from math import factorial






class __A     :



 '''simple docstring'''







 def __init__(self					,  A					,  A			)       ->	str:


      """simple docstring"""



      _a           =    real
      if isinstance(A					,  A			):
           _a           =    [1] * rank
      else:
           _a           =    rank



 def __repr__(self			)       ->	List[Any]:


      """simple docstring"""



      return (
          f'''{self.real}+'''
          f'''{'+'.join(str(A			)+'E'+str(n+1			)for n,dual in enumerate(self.duals			)			)}'''
      )



 def    a__    (self			)       ->	List[Any]:


      """simple docstring"""



      _a           =    self.duals.copy()
      while cur[-1] == 0:
           cur.pop(-1			)
      return Dual(self.real					,  A			)



 def __add__(self					,  A			)       ->	int:


      """simple docstring"""



      if not isinstance(A					,  A			):
           return Dual(self.real + other					,  self.duals			)
      _a           =    self.duals.copy()
      _a           =    other.duals.copy()
      if len(A			) > len(A			):
           o_dual.extend([1] * (len(A			) - len(A			))			)
      elif len(A			) < len(A			):
           s_dual.extend([1] * (len(A			) - len(A			))			)
      _a           =    []
      for i in range(len(A			)			):
           new_duals.append(s_dual[i] + o_dual[i]			)
      return Dual(self.real + other.real					,  A			)

 __lowerCamelCase       :			Optional[Any]		=			__add__



 def __sub__(self					,  A			)       ->	Optional[Any]:


      """simple docstring"""



      return self + other * -1



 def __mul__(self					,  A			)       ->	Union[str, Any]:


      """simple docstring"""



      if not isinstance(A					,  A			):
           _a           =    []
           for i in self.duals:
                new_duals.append(i * other			)
           return Dual(self.real * other					,  A			)
      _a           =    [0] * (len(self.duals			) + len(other.duals			) + 1)
      for i, item in enumerate(self.duals			):
           for j, jtem in enumerate(other.duals			):
                new_duals[i + j + 1] += item * jtem
      for k in range(len(self.duals			)			):
           new_duals[k] += self.duals[k] * other.real
      for index in range(len(other.duals			)			):
           new_duals[index] += other.duals[index] * self.real
      return Dual(self.real * other.real					,  A			)

 __lowerCamelCase       :			Optional[Any]		=			__mul__



 def __truediv__(self					,  A			)       ->	Optional[Any]:


      """simple docstring"""



      if not isinstance(A					,  A			):
           _a           =    []
           for i in self.duals:
                new_duals.append(i / other			)
           return Dual(self.real / other					,  A			)
      raise ValueError



 def __floordiv__(self					,  A			)       ->	str:


      """simple docstring"""



      if not isinstance(A					,  A			):
           _a           =    []
           for i in self.duals:
                new_duals.append(i // other			)
           return Dual(self.real // other					,  A			)
      raise ValueError



 def __pow__(self					,  A			)       ->	Optional[Any]:


      """simple docstring"""



      if n < 0 or isinstance(A					,  A			):
           raise ValueError('''power must be a positive integer'''			)
      if n == 0:
           return 1
      if n == 1:
           return self
      _a           =    self
      for _ in range(n - 1			):
           x *= self
      return x





def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



     if not callable(__A):
          raise ValueError('''differentiate() requires a function as input for func''')
     if not isinstance(__A    ,      (float, int)):
          raise ValueError('''differentiate() requires a float as input for position''')
     if not isinstance(__A    ,      __A):
          raise ValueError('''differentiate() requires an int as input for order''')
     _a           =    Dual(__A    ,      1)
     _a           =    func(__A)
     if order == 0:
          return result.real
     return result.duals[order - 1] * factorial(__A)


if __name__ == "__main__":
  import doctest

  doctest.testmod()




  def lowerCAmelCase    (__A):



       """simple docstring"""



       return y**2 * y**4
  print(differentiate(f, 9, 2))







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


_lowercase							:   Optional[int]						=						False






@skip_mps
class    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			StableDiffusionAttendAndExcitePipeline
				lowerCAmelCase					=			False
				lowerCAmelCase					=			TEXT_TO_IMAGE_PARAMS
				lowerCAmelCase					=			TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}					)
				lowerCAmelCase					=			TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCAmelCase					=			TEXT_TO_IMAGE_IMAGE_PARAMS

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					List[Any]:
					super().setUpClass()
					torch.use_deterministic_algorithms(a__ )

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Tuple:
					super().tearDownClass()
					torch.use_deterministic_algorithms(a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					torch.manual_seed(0 )
					A             =					UNetaDConditionModel(
					    block_out_channels=(32, 64)					, layers_per_block=1					, sample_size=32					, in_channels=4					, out_channels=4					, down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")					, up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")					, cross_attention_dim=32					, attention_head_dim=(2, 4)					, use_linear_projection=a__					, )
					A             =					DDIMScheduler(
					    beta_start=0.0_00_85					, beta_end=0.0_12					, beta_schedule="""scaled_linear"""					, clip_sample=a__					, set_alpha_to_one=a__					, )
					torch.manual_seed(0 )
					A             =					AutoencoderKL(
					    block_out_channels=[32, 64]					, in_channels=3					, out_channels=3					, down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]					, up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]					, latent_channels=4					, sample_size=128					, )
					torch.manual_seed(0 )
					A             =					CLIPTextConfig(
					    bos_token_id=0					, eos_token_id=2					, hidden_size=32					, intermediate_size=37					, layer_norm_eps=1e-05					, num_attention_heads=4					, num_hidden_layers=5					, pad_token_id=1					, vocab_size=1000					, hidden_act="""gelu"""					, projection_dim=512					, )
					A             =					CLIPTextModel(a__ )
					A             =					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

					A             =					{
					    """unet""": unet,
					    """scheduler""": scheduler,
					    """vae""": vae,
					    """text_encoder""": text_encoder,
					    """tokenizer""": tokenizer,
					    """safety_checker""": None,
					    """feature_extractor""": None,
					}

					return components

				def   _UpperCAmelCase       (    self					, a__					, a__=0 )						->					Optional[Any]:
					if str(a__ ).startswith("""mps""" ):
						A             =					torch.manual_seed(a__ )
					else:
						A             =					torch.Generator(device=a__ ).manual_seed(a__ )
					A             =					A             =					{
					    """prompt""": """a cat and a frog""",
					    """token_indices""": [2, 5],
					    """generator""": generator,
					    """num_inference_steps""": 1,
					    """guidance_scale""": 6.0,
					    """output_type""": """numpy""",
					    """max_iter_to_alter""": 2,
					    """thresholds""": {0: 0.7},
					}
					return inputs

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					"""cpu"""

					A             =					self.get_dummy_components()
					A             =					self.pipeline_class(**a__ )
					pipe.to(a__ )
					pipe.set_progress_bar_config(disable=a__ )

					A             =					self.get_dummy_inputs(a__ )
					A             =					pipe(**a__ ).images
					A             =					image[0, -3:, -3:, -1]

					self.assertEqual(image.shape					, (1, 64, 64, 3) )
					A             =					np.array(
					    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96] )
					A             =					np.abs(image_slice.flatten() - expected_slice ).max()
					self.assertLessEqual(a__					, 1e-3 )

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					super().test_cpu_offload_forward_pass(expected_max_diff=5e-4 )

				def   _UpperCAmelCase       (    self )						->					Dict:
					# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
					self._test_inference_batch_consistent(batch_sizes=[1, 2] )

				def   _UpperCAmelCase       (    self )						->					Any:
					self._test_inference_batch_single_identical(batch_size=2					, expected_max_diff=7e-4 )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )

				def   _UpperCAmelCase       (    self )						->					str:
					super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4 )

				def   _UpperCAmelCase       (    self )						->					int:
					super().test_save_load_local(expected_max_difference=5e-4 )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().test_save_load_optional_components(expected_max_difference=4e-4 )






@require_torch_gpu
@slow
class    _UpperCamelCase     (       unittest.TestCase					):

				"""simple docstring"""







				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Tuple:
					super().setUpClass()
					torch.use_deterministic_algorithms(a__ )

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Dict:
					super().tearDownClass()
					torch.use_deterministic_algorithms(a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()

				def   _UpperCAmelCase       (    self )						->					int:
					A             =					torch.manual_seed(51 )

					A             =					StableDiffusionAttendAndExcitePipeline.from_pretrained(
					    """CompVis/stable-diffusion-v1-4"""					, safety_checker=a__					, torch_dtype=torch.floataa )
					pipe.to("""cuda""" )

					A             =					"""a painting of an elephant with glasses"""
					A             =					[5, 7]

					A             =					pipe(
					    prompt=a__					, token_indices=a__					, guidance_scale=7.5					, generator=a__					, num_inference_steps=5					, max_iter_to_alter=5					, output_type="""numpy"""					, ).images[0]

					A             =					load_numpy(
					    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy""" )
					assert np.abs((expected_image - image).max() ) < 5e-1



