
import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_ ,		unittest.TestCase     ):

							"""simple docstring"""






							_snake_case  		=	KandinskyPipeline
							_snake_case  		=	[
							    'prompt',
							    'image_embeds',
							    'negative_image_embeds',
							]
							_snake_case  		=	['prompt', 'negative_prompt', 'image_embeds', 'negative_image_embeds']
							_snake_case  		=	[
							    'generator',
							    'height',
							    'width',
							    'latents',
							    'guidance_scale',
							    'negative_prompt',
							    'num_inference_steps',
							    'return_dict',
							    'guidance_scale',
							    'num_images_per_prompt',
							    'output_type',
							    'return_dict',
							]
							_snake_case  		=	False



							@property
							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													return 32



							@property
							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													return 32



							@property
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													return self.time_input_dim



							@property
							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													return self.time_input_dim * 4



							@property
							def      A__		(	self      )-> int:





													'''simple docstring'''






													return 100



							@property
							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''      )
													return tokenizer



							@property
							def      A__		(	self      )-> Any:





													'''simple docstring'''






													torch.manual_seed(0      )
													__UpperCamelCase  	=      MCLIPConfig(
													    numDims=self.cross_attention_dim  ,						transformerDimensions=self.text_embedder_hidden_size  ,						hidden_size=self.text_embedder_hidden_size  ,						intermediate_size=37  ,						num_attention_heads=4  ,						num_hidden_layers=5  ,						vocab_size=1005  ,						)

													__UpperCamelCase  	=      MultilingualCLIP(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      text_encoder.eval()

													return text_encoder



							@property
							def      A__		(	self      )-> int:





													'''simple docstring'''






													torch.manual_seed(0      )

													__UpperCamelCase  	=      {
													    '''in_channels''': 4,
													    # Out channels is double in channels because predicts mean and variance
													    '''out_channels''': 8,
													    '''addition_embed_type''': '''text_image''',
													    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
													    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
													    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
													    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
													    '''layers_per_block''': 1,
													    '''encoder_hid_dim''': self.text_embedder_hidden_size,
													    '''encoder_hid_dim_type''': '''text_image_proj''',
													    '''cross_attention_dim''': self.cross_attention_dim,
													    '''attention_head_dim''': 4,
													    '''resnet_time_scale_shift''': '''scale_shift''',
													    '''class_embed_type''': None,
													}

													__UpperCamelCase  	=      UNetaDConditionModel(**SCREAMING_SNAKE_CASE_      )
													return model



							@property
							def      A__		(	self      )-> Union[str, Any]:





													'''simple docstring'''






													return {
													    "block_out_channels": [32, 64],
													    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
													    "in_channels": 3,
													    "latent_channels": 4,
													    "layers_per_block": 1,
													    "norm_num_groups": 8,
													    "norm_type": "spatial",
													    "num_vq_embeddings": 12,
													    "out_channels": 3,
													    "up_block_types": [
													        "AttnUpDecoderBlock2D",
													        "UpDecoderBlock2D",
													    ],
													    "vq_embed_dim": 4,
													}



							@property
							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													torch.manual_seed(0      )
													__UpperCamelCase  	=      VQModel(**self.dummy_movq_kwargs      )
													return model



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.dummy_text_encoder
													__UpperCamelCase  	=      self.dummy_tokenizer
													__UpperCamelCase  	=      self.dummy_unet
													__UpperCamelCase  	=      self.dummy_movq

													__UpperCamelCase  	=      DDIMScheduler(
													    num_train_timesteps=1000  ,						beta_schedule='''linear'''  ,						beta_start=0.0_0_0_8_5  ,						beta_end=0.0_1_2  ,						clip_sample=SCREAMING_SNAKE_CASE_  ,						set_alpha_to_one=SCREAMING_SNAKE_CASE_  ,						steps_offset=1  ,						prediction_type='''epsilon'''  ,						thresholding=SCREAMING_SNAKE_CASE_  ,						)

													__UpperCamelCase  	=      {
													    '''text_encoder''': text_encoder,
													    '''tokenizer''': tokenizer,
													    '''unet''': unet,
													    '''scheduler''': scheduler,
													    '''movq''': movq,
													}
													return components



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=0      )-> List[str]:





													'''simple docstring'''






													__UpperCamelCase  	=      floats_tensor((1, self.cross_attention_dim)  ,						rng=random.Random(SCREAMING_SNAKE_CASE_      )      ).to(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      floats_tensor((1, self.cross_attention_dim)  ,						rng=random.Random(seed + 1      )      ).to(SCREAMING_SNAKE_CASE_      )
													if str(SCREAMING_SNAKE_CASE_      ).startswith('''mps'''      ):
																			__UpperCamelCase  	=      torch.manual_seed(SCREAMING_SNAKE_CASE_      )
													else:
																			__UpperCamelCase  	=      torch.Generator(device=SCREAMING_SNAKE_CASE_      ).manual_seed(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      {
													    '''prompt''': '''horse''',
													    '''image_embeds''': image_embeds,
													    '''negative_image_embeds''': negative_image_embeds,
													    '''generator''': generator,
													    '''height''': 64,
													    '''width''': 64,
													    '''guidance_scale''': 4.0,
													    '''num_inference_steps''': 2,
													    '''output_type''': '''np''',
													}
													return inputs



							def      A__		(	self      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      '''cpu'''

													__UpperCamelCase  	=      self.get_dummy_components()

													__UpperCamelCase  	=      self.pipeline_class(**SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      pipe.to(SCREAMING_SNAKE_CASE_      )

													pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE_      )      )
													__UpperCamelCase  	=      output.images

													__UpperCamelCase  	=      pipe(
													    **self.get_dummy_inputs(SCREAMING_SNAKE_CASE_      )  ,						return_dict=SCREAMING_SNAKE_CASE_  ,						)[0]

													__UpperCamelCase  	=      image[0, -3:, -3:, -1]
													__UpperCamelCase  	=      image_from_tuple[0, -3:, -3:, -1]

													assert image.shape == (1, 64, 64, 3)

													__UpperCamelCase  	=      np.array(
													    [0.3_2_8_6_6_3, 1.0, 0.2_3_2_1_6_8_7_3, 1.0, 0.9_2_7_1_7_5_6_4, 0.4_6_3_9_0_4_6, 0.9_6_8_9_4_7_7_7, 0.3_1_7_1_3_3_7_8, 0.6_2_9_3_9_5_3]      )

													assert (
													    np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2
													), F" expected_slice {expected_slice}, but got {image_slice.flatten()}"
													assert (
													    np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1E-2
													), F" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"






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

							"""simple docstring"""






							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      load_numpy(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
													    '''/kandinsky/kandinsky_text2img_cat_fp16.npy'''      )

													__UpperCamelCase  	=      KandinskyPriorPipeline.from_pretrained(
													    '''kandinsky-community/kandinsky-2-1-prior'''  ,						torch_dtype=torch.floataa      )
													pipe_prior.to(SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      KandinskyPipeline.from_pretrained('''kandinsky-community/kandinsky-2-1'''  ,						torch_dtype=torch.floataa      )
													__UpperCamelCase  	=      pipeline.to(SCREAMING_SNAKE_CASE_      )
													pipeline.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      '''red cat, 4k photo'''

													__UpperCamelCase  	=      torch.Generator(device='''cuda'''      ).manual_seed(0      )
													__UpperCamelCase	,				__UpperCamelCase  	=      pipe_prior(
													    SCREAMING_SNAKE_CASE_  ,						generator=SCREAMING_SNAKE_CASE_  ,						num_inference_steps=5  ,						negative_prompt=''''''  ,						).to_tuple()

													__UpperCamelCase  	=      torch.Generator(device='''cuda'''      ).manual_seed(0      )
													__UpperCamelCase  	=      pipeline(
													    SCREAMING_SNAKE_CASE_  ,						image_embeds=SCREAMING_SNAKE_CASE_  ,						negative_image_embeds=SCREAMING_SNAKE_CASE_  ,						generator=SCREAMING_SNAKE_CASE_  ,						num_inference_steps=100  ,						output_type='''np'''  ,						)

													__UpperCamelCase  	=      output.images[0]

													assert image.shape == (512, 512, 3)

													assert_mean_pixel_difference(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )










import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

a_ 		=  logging.get_logger(__name__)




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_ = True   )							->						Dict:

    """simple docstring"""


    __UpperCamelCase			=    {}
    for name in model.attn_processors.keys():
        __UpperCamelCase			=    name.endswith('''attn2.processor'''   ) and not (
            name.startswith('''transformer_in'''   ) or '''temp_attentions''' in name.split('''.'''   )
        )
        __UpperCamelCase			=    model.config.cross_attention_dim if has_cross_attention else None
        if name.startswith('''mid_block'''   ):
            __UpperCamelCase			=    model.config.block_out_channels[-1]
        elif name.startswith('''up_blocks'''   ):
            __UpperCamelCase			=    int(name[len('''up_blocks.'''   )]   )
            __UpperCamelCase			=    list(reversed(model.config.block_out_channels   )   )[block_id]
        elif name.startswith('''down_blocks'''   ):
            __UpperCamelCase			=    int(name[len('''down_blocks.'''   )]   )
            __UpperCamelCase			=    model.config.block_out_channels[block_id]
        elif name.startswith('''transformer_in'''   ):
            # Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
            __UpperCamelCase			=    8 * model.config.attention_head_dim

        __UpperCamelCase			=    LoRAAttnProcessor(hidden_size=lowercase_       ,  cross_attention_dim=lowercase_   )
        __UpperCamelCase			=    lora_attn_procs[name].to(model.device   )

        if mock_weights:
            # add 1 to weights to mock trained weights
            with torch.no_grad():
                lora_attn_procs[name].to_q_lora.up.weight += 1
                lora_attn_procs[name].to_k_lora.up.weight += 1
                lora_attn_procs[name].to_v_lora.up.weight += 1
                lora_attn_procs[name].to_out_lora.up.weight += 1

    return lora_attn_procs


@skip_mps
class 			_lowerCamelCase    (      _SCREAMING_SNAKE_CASE				,      _SCREAMING_SNAKE_CASE				,      unittest.TestCase ):

      """simple docstring"""

      lowerCAmelCase__      :			Dict     =       UNetaDConditionModel
      lowerCAmelCase__      :			Any     =       "sample"







      @property
      def    snake_case						(  self       :			Any					):
          __UpperCamelCase			=    4
          __UpperCamelCase			=    4
          __UpperCamelCase			=    4
          __UpperCamelCase			=    (32, 32)

          __UpperCamelCase			=    floats_tensor((batch_size, num_channels, num_frames) + sizes					).to(snake_case					)
          __UpperCamelCase			=    torch.tensor([10]					).to(snake_case					)
          __UpperCamelCase			=    floats_tensor((batch_size, 4, 32)					).to(snake_case					)

          return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}







      @property
      def    snake_case						(  self       :			Tuple					):
          return (4, 4, 32, 32)







      @property
      def    snake_case						(  self       :			Optional[int]					):
          return (4, 4, 32, 32)







      def    snake_case						(  self       :			int					):
          __UpperCamelCase			=    {
              '''block_out_channels''': (32, 64),
              '''down_block_types''': (
                  '''CrossAttnDownBlock3D''',
                  '''DownBlock3D''',
              ),
              '''up_block_types''': ('''UpBlock3D''', '''CrossAttnUpBlock3D'''),
              '''cross_attention_dim''': 32,
              '''attention_head_dim''': 8,
              '''out_channels''': 4,
              '''in_channels''': 4,
              '''layers_per_block''': 1,
              '''sample_size''': 32,
          }
          __UpperCamelCase			=    self.dummy_input
          return init_dict, inputs_dict







      @unittest.skipIf(
          torch_device != '''cuda''' or not is_xformers_available()			,							reason='''XFormers attention is only available with CUDA and `xformers` installed'''			,							)
      def    snake_case						(  self       :			Any					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()
          __UpperCamelCase			=    self.model_class(**snake_case					)

          model.enable_xformers_memory_efficient_attention()

          assert (
              model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
              == "XFormersAttnProcessor"
          ), "xformers is not enabled"







      def    snake_case						(  self       :			str					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    32

          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)
          model.eval()

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					)

              if isinstance(snake_case			,							snake_case					):
                  __UpperCamelCase			=    output.sample

          self.assertIsNotNone(snake_case					)
          __UpperCamelCase			=    inputs_dict['''sample'''].shape
          self.assertEqual(output.shape			,							snake_case			,							'''Input and output shapes do not match'''					)







      def    snake_case						(  self       :			Union[str, Any]					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)
          model.eval()

          with torch.no_grad():
              # Warmup pass when using mps (see #372)
              if torch_device == "mps" and isinstance(snake_case			,							snake_case					):
                  model(**self.dummy_input					)

              __UpperCamelCase			=    model(**snake_case					)
              if isinstance(snake_case			,							snake_case					):
                  __UpperCamelCase			=    first.sample

              __UpperCamelCase			=    model(**snake_case					)
              if isinstance(snake_case			,							snake_case					):
                  __UpperCamelCase			=    second.sample

          __UpperCamelCase			=    first.cpu().numpy()
          __UpperCamelCase			=    second.cpu().numpy()
          __UpperCamelCase			=    out_a[~np.isnan(snake_case					)]
          __UpperCamelCase			=    out_a[~np.isnan(snake_case					)]
          __UpperCamelCase			=    np.amax(np.abs(out_a - out_a					)					)
          self.assertLessEqual(snake_case			,							1E-5					)







      def    snake_case						(  self       :			int					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)
          model.eval()

          model.set_attention_slice('''auto'''					)
          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					)
          assert output is not None

          model.set_attention_slice('''max'''					)
          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					)
          assert output is not None

          model.set_attention_slice(2					)
          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					)
          assert output is not None







      def    snake_case						(  self       :			int					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					).sample

          __UpperCamelCase			=    create_lora_layers(snake_case					)

          # make sure we can set a list of attention processors
          model.set_attn_processor(snake_case					)
          model.to(snake_case					)

          # test that attn processors can be set to itself
          model.set_attn_processor(model.attn_processors					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.0}					).sample
              __UpperCamelCase			=    model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.5}					).sample
              __UpperCamelCase			=    model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.5}					).sample

          assert (samplea - samplea).abs().max() < 3E-3
          assert (samplea - samplea).abs().max() < 3E-3

          # sample 2 and sample 3 should be different
          assert (samplea - samplea).abs().max() > 3E-3







      def    snake_case						(  self       :			List[str]					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          torch.manual_seed(0					)
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					).sample

          __UpperCamelCase			=    create_lora_layers(snake_case					)
          model.set_attn_processor(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.5}					).sample

          with tempfile.TemporaryDirectory() as tmpdirname:
              model.save_attn_procs(snake_case					)
              self.assertTrue(os.path.isfile(os.path.join(snake_case			,							'''pytorch_lora_weights.bin'''					)					)					)
              torch.manual_seed(0					)
              __UpperCamelCase			=    self.model_class(**snake_case					)
              new_model.to(snake_case					)
              new_model.load_attn_procs(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    new_model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.5}					).sample

          assert (sample - new_sample).abs().max() < 1E-3

          # LoRA and no LoRA should NOT be the same
          assert (sample - old_sample).abs().max() > 1E-4







      def    snake_case						(  self       :			Optional[Any]					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          torch.manual_seed(0					)
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					).sample

          __UpperCamelCase			=    create_lora_layers(snake_case					)
          model.set_attn_processor(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.5}					).sample

          with tempfile.TemporaryDirectory() as tmpdirname:
              model.save_attn_procs(snake_case			,							safe_serialization=snake_case					)
              self.assertTrue(os.path.isfile(os.path.join(snake_case			,							'''pytorch_lora_weights.safetensors'''					)					)					)
              torch.manual_seed(0					)
              __UpperCamelCase			=    self.model_class(**snake_case					)
              new_model.to(snake_case					)
              new_model.load_attn_procs(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    new_model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.5}					).sample

          assert (sample - new_sample).abs().max() < 3E-3

          # LoRA and no LoRA should NOT be the same
          assert (sample - old_sample).abs().max() > 1E-4







      def    snake_case						(  self       :			Optional[int]					):
          # enable deterministic behavior for gradient checkpointing
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          torch.manual_seed(0					)
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)

          __UpperCamelCase			=    create_lora_layers(snake_case			,							mock_weights=snake_case					)
          model.set_attn_processor(snake_case					)
          # Saving as torch, properly reloads with directly filename
          with tempfile.TemporaryDirectory() as tmpdirname:
              model.save_attn_procs(snake_case					)
              self.assertTrue(os.path.isfile(os.path.join(snake_case			,							'''pytorch_lora_weights.bin'''					)					)					)
              torch.manual_seed(0					)
              __UpperCamelCase			=    self.model_class(**snake_case					)
              new_model.to(snake_case					)
              new_model.load_attn_procs(snake_case			,							weight_name='''pytorch_lora_weights.bin'''					)







      def    snake_case						(  self       :			List[str]					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          torch.manual_seed(0					)
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)

          __UpperCamelCase			=    create_lora_layers(snake_case			,							mock_weights=snake_case					)
          model.set_attn_processor(snake_case					)
          # Saving as torch, properly reloads with directly filename
          with tempfile.TemporaryDirectory() as tmpdirname:
              model.save_attn_procs(snake_case					)
              self.assertTrue(os.path.isfile(os.path.join(snake_case			,							'''pytorch_lora_weights.bin'''					)					)					)
              torch.manual_seed(0					)
              __UpperCamelCase			=    self.model_class(**snake_case					)
              new_model.to(snake_case					)
              with self.assertRaises(snake_case					) as e:
                  new_model.load_attn_procs(snake_case			,							use_safetensors=snake_case					)
              self.assertIn('''Error no file named pytorch_lora_weights.safetensors'''			,							str(e.exception					)					)







      def    snake_case						(  self       :			Optional[Any]					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    8

          torch.manual_seed(0					)
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					).sample

          __UpperCamelCase			=    create_lora_layers(snake_case					)
          model.set_attn_processor(snake_case					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case			,							cross_attention_kwargs={'''scale''': 0.0}					).sample

          model.set_attn_processor(AttnProcessor()					)

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					).sample

          assert (sample - new_sample).abs().max() < 1E-4
          assert (sample - old_sample).abs().max() < 3E-3







      @unittest.skipIf(
          torch_device != '''cuda''' or not is_xformers_available()			,							reason='''XFormers attention is only available with CUDA and `xformers` installed'''			,							)
      def    snake_case						(  self       :			Union[str, Any]					):
          # enable deterministic behavior for gradient checkpointing
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()

          __UpperCamelCase			=    4

          torch.manual_seed(0					)
          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)
          __UpperCamelCase			=    create_lora_layers(snake_case					)
          model.set_attn_processor(snake_case					)

          # default
          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					).sample

              model.enable_xformers_memory_efficient_attention()
              __UpperCamelCase			=    model(**snake_case					).sample

              model.disable_xformers_memory_efficient_attention()
              __UpperCamelCase			=    model(**snake_case					).sample

          assert (sample - on_sample).abs().max() < 1E-4
          assert (sample - off_sample).abs().max() < 1E-4







      def    snake_case						(  self       :			Dict					):
          __UpperCamelCase		,   __UpperCamelCase			=    self.prepare_init_args_and_inputs_for_common()
          __UpperCamelCase			=    32

          __UpperCamelCase			=    self.model_class(**snake_case					)
          model.to(snake_case					)
          model.eval()

          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					)[0]

          model.enable_forward_chunking()
          with torch.no_grad():
              __UpperCamelCase			=    model(**snake_case					)[0]

          self.assertEqual(output.shape			,							output_a.shape			,							'''Shape doesn\'t match'''					)
          assert np.abs(output.cpu() - output_a.cpu()					).max() < 1E-2


# (todo: sayakpaul) implement SLOW tests.






