




import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
       MODEL_MAPPING,
       EfficientFormerForImageClassification,
       EfficientFormerForImageClassificationWithTeacher,
       EfficientFormerModel,
   )
   from transformers.models.efficientformer.modeling_efficientformer import (
       EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
   )


if is_vision_available():
   from PIL import Image

   from transformers import EfficientFormerImageProcessor




class     a__ :







     def __init__(			self						,	A						,	A = 13						,	A = 64						,	A = 2						,	A = 3						,	A = 3						,	A = True						,	A = True						,	A = 128						,	A=[16, 32, 64, 128]						,	A = 7						,	A = 4						,	A = 37						,	A = "gelu"						,	A = 0.1						,	A = 0.1						,	A = 10						,	A = 0.0_2						,	A = 2						,	A = 1						,	A = 128						,	A = [2, 2, 2, 2]						,	A = 2						,	A = 2						,	)						->					Union[str, Any]:



          '''simple docstring'''



          a											=   parent
          a											=   batch_size
          a											=   image_size
          a											=   patch_size
          a											=   num_channels
          a											=   is_training
          a											=   use_labels
          a											=   hidden_size
          a											=   num_hidden_layers
          a											=   num_attention_heads
          a											=   intermediate_size
          a											=   hidden_act
          a											=   hidden_dropout_prob
          a											=   attention_probs_dropout_prob
          a											=   type_sequence_label_size
          a											=   initializer_range
          a											=   encoder_stride
          a											=   num_attention_outputs
          a											=   embed_dim
          a											=   embed_dim + 1
          a											=   resolution
          a											=   depths
          a											=   hidden_sizes
          a											=   dim
          a											=   mlp_expansion_ratio







     def     lowerCAmelCase_       (			self				)						->					str:



          '''simple docstring'''



          a											=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

          a											=   None
          if self.use_labels:
               a											=   ids_tensor([self.batch_size]						,	self.type_sequence_label_size				)

          a											=   self.get_config()
          return config, pixel_values, labels







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



          '''simple docstring'''



          return EfficientFormerConfig(
              image_size=self.image_size						,	patch_size=self.patch_size						,	num_channels=self.num_channels						,	hidden_size=self.hidden_size						,	num_hidden_layers=self.num_hidden_layers						,	num_attention_heads=self.num_attention_heads						,	intermediate_size=self.intermediate_size						,	hidden_act=self.hidden_act						,	hidden_dropout_prob=self.hidden_dropout_prob						,	attention_probs_dropout_prob=self.attention_probs_dropout_prob						,	is_decoder=A						,	initializer_range=self.initializer_range						,	encoder_stride=self.encoder_stride						,	resolution=self.resolution						,	depths=self.depths						,	hidden_sizes=self.hidden_sizes						,	dim=self.dim						,	mlp_expansion_ratio=self.mlp_expansion_ratio						,	)







     def     lowerCAmelCase_       (			self						,	A						,	A						,	A				)						->					Tuple:



          '''simple docstring'''



          a											=   EfficientFormerModel(config=A				)
          model.to(A				)
          model.eval()
          a											=   model(A				)
          self.parent.assertEqual(result.last_hidden_state.shape						,	(self.batch_size, self.seq_length, self.hidden_size)				)







     def     lowerCAmelCase_       (			self						,	A						,	A						,	A				)						->					Optional[int]:



          '''simple docstring'''



          a											=   self.type_sequence_label_size
          a											=   EfficientFormerForImageClassification(A				)
          model.to(A				)
          model.eval()
          a											=   model(A						,	labels=A				)
          self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.type_sequence_label_size)				)

          # test greyscale images
          a											=   1
          a											=   EfficientFormerForImageClassification(A				)
          model.to(A				)
          model.eval()

          a											=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
          a											=   model(A				)
          self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.type_sequence_label_size)				)







     def     lowerCAmelCase_       (			self				)						->					str:



          '''simple docstring'''



          a											=   self.prepare_config_and_inputs()
          (
              (
              a       
          )						,   (
              a       
          )						,   (
              a       
          )						,          
          )											=   config_and_inputs
          a											=   {"pixel_values": pixel_values}
          return config, inputs_dict







@require_torch
class     a__ (      _UpperCAmelCase     ,      _UpperCAmelCase     ,      unittest.TestCase   ):
     a	:    List[Any]	      =			(
         (
             EfficientFormerModel,
             EfficientFormerForImageClassificationWithTeacher,
             EfficientFormerForImageClassification,
         )
         if is_torch_available()
         else ()
     )
     a	:    str	      =			(
         {
             """feature-extraction""": EfficientFormerModel,
             """image-classification""": (
                 EfficientFormerForImageClassification,
                 EfficientFormerForImageClassificationWithTeacher,
             ),
         }
         if is_torch_available()
         else {}
     )
     a	:    Any	      =			False

     a	:    int	      =			False
     a	:    List[str]	      =			False
     a	:    str	      =			False







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



          '''simple docstring'''



          a											=   EfficientFormerModelTester(self				)
          a											=   ConfigTester(
              self						,	config_class=A						,	has_text_modality=A						,	hidden_size=37				)







     def     lowerCAmelCase_       (			self				)						->					Tuple:



          '''simple docstring'''



          self.config_tester.run_common_tests()







     @unittest.skip(reason="EfficientFormer does not use inputs_embeds"				)
     def     lowerCAmelCase_       (			self				)						->					Union[str, Any]:



          '''simple docstring'''



          pass







     @unittest.skip(reason="EfficientFormer does not support input and output embeddings"				)
     def     lowerCAmelCase_       (			self				)						->					Optional[Any]:



          '''simple docstring'''



          pass







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



          '''simple docstring'''



          a						,   a											=   self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               a											=   model_class(A				)
               a											=   inspect.signature(model.forward				)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               a											=   [*signature.parameters.keys()]

               a											=   ["pixel_values"]
               self.assertListEqual(arg_names[:1]						,	A				)







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



          '''simple docstring'''



          def check_hidden_states_output(A						,	A						,	A				):
               a											=   model_class(A				)
               model.to(A				)
               model.eval()

               with torch.no_grad():
                    a											=   model(**self._prepare_for_class(A						,	A				)				)

               a											=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

               a											=   getattr(
                   self.model_tester						,	"expected_num_hidden_layers"						,	self.model_tester.num_hidden_layers + 1				)
               self.assertEqual(len(A				)						,	A				)

               if hasattr(self.model_tester						,	"encoder_seq_length"				):
                    a											=   self.model_tester.encoder_seq_length
                    if hasattr(self.model_tester						,	"chunk_length"				) and self.model_tester.chunk_length > 1:
                         a											=   seq_length * self.model_tester.chunk_length
               else:
                    a											=   self.model_tester.seq_length

               self.assertListEqual(
                   list(hidden_states[-1].shape[-2:]				)						,	[seq_length, self.model_tester.hidden_size]						,	)

               if config.is_encoder_decoder:
                    a											=   outputs.decoder_hidden_states

                    self.assertIsInstance(A						,	(list, tuple)				)
                    self.assertEqual(len(A				)						,	A				)
                    a											=   getattr(self.model_tester						,	"seq_length"						,	A				)
                    a											=   getattr(self.model_tester						,	"decoder_seq_length"						,	A				)

                    self.assertListEqual(
                        list(hidden_states[-1].shape[-2:]				)						,	[decoder_seq_length, self.model_tester.hidden_size]						,	)

          a						,   a											=   self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               a											=   True
               check_hidden_states_output(A						,	A						,	A				)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               a											=   True

               check_hidden_states_output(A						,	A						,	A				)







     def     lowerCAmelCase_       (			self						,	A						,	A						,	A=False				)						->					List[str]:



          '''simple docstring'''



          a											=   super()._prepare_for_class(A						,	A						,	return_labels=A				)

          if return_labels:
               if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
                    del inputs_dict["labels"]

          return inputs_dict







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



          '''simple docstring'''



          a											=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A				)







     @unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"				)
     def     lowerCAmelCase_       (			self				)						->					Any:



          '''simple docstring'''



          a											=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*A				)







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



          '''simple docstring'''



          a											=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*A				)







     def     lowerCAmelCase_       (			self				)						->					Optional[Any]:



          '''simple docstring'''



          if not self.model_tester.is_training:
               return

          a						,   a											=   self.model_tester.prepare_config_and_inputs_for_common()
          a											=   True

          for model_class in self.all_model_classes:
               # EfficientFormerForImageClassificationWithTeacher supports inference-only
               if (
                   model_class in get_values(A				)
                   or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
               ):
                    continue
               a											=   model_class(A				)
               model.to(A				)
               model.train()
               a											=   self._prepare_for_class(A						,	A						,	return_labels=A				)
               a											=   model(**A				).loss
               loss.backward()







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



          '''simple docstring'''



          a						,   a											=   self.model_tester.prepare_config_and_inputs_for_common()

          a											=   [
              {"title": "multi_label_classification", "num_labels": 2, "dtype": torch.float},
              {"title": "single_label_classification", "num_labels": 1, "dtype": torch.long},
              {"title": "regression", "num_labels": 1, "dtype": torch.float},
          ]

          for model_class in self.all_model_classes:
               if (
                   model_class
                   not in [
                       *get_values(A				),
                   ]
                   or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
               ):
                    continue

               for problem_type in problem_types:
                    with self.subTest(msg=F'''Testing {model_class} with {problem_type["title"]}'''				):
                         a											=   problem_type["title"]
                         a											=   problem_type["num_labels"]

                         a											=   model_class(A				)
                         model.to(A				)
                         model.train()

                         a											=   self._prepare_for_class(A						,	A						,	return_labels=A				)

                         if problem_type["num_labels"] > 1:
                              a											=   inputs["labels"].unsqueeze(1				).repeat(1						,	problem_type["num_labels"]				)

                         a											=   inputs["labels"].to(problem_type["dtype"]				)

                         # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                         # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                         # they have the same size." which is a symptom something in wrong for the regression problem.
                         # See https://github.com/huggingface/transformers/issues/11780
                         with warnings.catch_warnings(record=A				) as warning_list:
                              a											=   model(**A				).loss
                         for w in warning_list:
                              if "Using a target size that is different to the input size" in str(w.message				):
                                   raise ValueError(
                                       F'''Something is going wrong in the regression problem: intercepted {w.message}'''				)

                         loss.backward()







     @slow
     def     lowerCAmelCase_       (			self				)						->					Optional[Any]:



          '''simple docstring'''



          for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               a											=   EfficientFormerModel.from_pretrained(A				)
               self.assertIsNotNone(A				)







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



          '''simple docstring'''



          a						,   a											=   self.model_tester.prepare_config_and_inputs_for_common()
          a											=   True

          a											=   getattr(self.model_tester						,	"seq_length"						,	A				)
          a											=   getattr(self.model_tester						,	"encoder_seq_length"						,	A				)
          a											=   getattr(self.model_tester						,	"key_length"						,	A				)
          a											=   getattr(self.model_tester						,	"chunk_length"						,	A				)

          if chunk_length is not None and hasattr(self.model_tester						,	"num_hashes"				):
               a											=   encoder_seq_length * self.model_tester.num_hashes

          for model_class in self.all_model_classes:
               a											=   True
               a											=   False
               a											=   True
               a											=   model_class(A				)
               model.to(A				)
               model.eval()
               with torch.no_grad():
                    a											=   model(**self._prepare_for_class(A						,	A				)				)
               a											=   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
               self.assertEqual(len(A				)						,	self.model_tester.num_attention_outputs				)

               # check that output_attentions also work using config
               del inputs_dict["output_attentions"]
               a											=   True
               a											=   model_class(A				)
               model.to(A				)
               model.eval()
               with torch.no_grad():
                    a											=   model(**self._prepare_for_class(A						,	A				)				)
               a											=   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
               self.assertEqual(len(A				)						,	self.model_tester.num_attention_outputs				)

               if chunk_length is not None:
                    self.assertListEqual(
                        list(attentions[0].shape[-4:]				)						,	[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]						,	)
               else:
                    self.assertListEqual(
                        list(attentions[0].shape[-3:]				)						,	[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]						,	)







def       SCREAMING_SNAKE_CASE							(     )    ->  Any:
     a											=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
     return image





@require_torch
@require_vision
class     a__ (      unittest.TestCase   ):







     @cached_property
     def     lowerCAmelCase_       (			self				)						->					str:



          '''simple docstring'''



          return (
              EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"				)
              if is_vision_available()
              else None
          )







     @slow
     def     lowerCAmelCase_       (			self				)						->					Dict:



          '''simple docstring'''



          a											=   EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"				).to(
              A				)

          a											=   self.default_image_processor
          a											=   prepare_img()
          a											=   image_processor(images=A						,	return_tensors="pt"				).to(A				)

          # forward pass
          with torch.no_grad():
               a											=   model(**A				)

          # verify the logits
          a											=   (1, 1000)
          self.assertEqual(outputs.logits.shape						,	A				)

          a											=   torch.tensor([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]				).to(A				)
          self.assertTrue(torch.allclose(outputs.logits[0][:3]						,	A						,	atol=1e-4				)				)







     @slow
     def     lowerCAmelCase_       (			self				)						->					Union[str, Any]:



          '''simple docstring'''



          a											=   EfficientFormerForImageClassificationWithTeacher.from_pretrained(
              "snap-research/efficientformer-l1-300"				).to(A				)

          a											=   self.default_image_processor
          a											=   prepare_img()
          a											=   image_processor(images=A						,	return_tensors="pt"				).to(A				)

          # forward pass
          with torch.no_grad():
               a											=   model(**A				)

          # verify the logits
          a											=   (1, 1000)
          self.assertEqual(outputs.logits.shape						,	A				)

          a											=   torch.tensor([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]				).to(A				)
          self.assertTrue(torch.allclose(outputs.logits[0][:3]						,	A						,	atol=1e-4				)				)







import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase)    ->  Tuple:
     a											=   {}
     for name in unet.attn_processors.keys():
          a											=   None if name.endswith("attn1.processor") else unet.config.cross_attention_dim
          if name.startswith("mid_block"):
               a											=   unet.config.block_out_channels[-1]
          elif name.startswith("up_blocks"):
               a											=   int(name[len("up_blocks.")])
               a											=   list(reversed(unet.config.block_out_channels))[block_id]
          elif name.startswith("down_blocks"):
               a											=   int(name[len("down_blocks.")])
               a											=   unet.config.block_out_channels[block_id]
          a											=   (
              LoRAAttnProcessor2_0 if hasattr(__UpperCamelCase	,      "scaled_dot_product_attention") else LoRAAttnProcessor
          )
          a											=   lora_attn_processor_class(
              hidden_size=__UpperCamelCase	,      cross_attention_dim=__UpperCamelCase)
     a											=   AttnProcsLayers(__UpperCamelCase)
     return lora_attn_procs, unet_lora_layers

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase)    ->  Optional[Any]:
     a											=   {}
     a											=   (
         LoRAAttnProcessor2_0 if hasattr(__UpperCamelCase	,      "scaled_dot_product_attention") else LoRAAttnProcessor
     )
     for name, module in text_encoder.named_modules():
          if name.endswith(__UpperCamelCase):
               a											=   lora_attn_processor_class(
                   hidden_size=module.out_proj.out_features	,      cross_attention_dim=__UpperCamelCase)
     return text_lora_attn_procs

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase)    ->  str:
     a											=   create_text_encoder_lora_attn_procs(__UpperCamelCase)
     a											=   AttnProcsLayers(__UpperCamelCase)
     return text_encoder_lora_layers

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase	,      __UpperCamelCase=False)    ->  Any:
     for _, attn_proc in text_lora_attn_procs.items():
          # set up.weights
          for layer_name, layer_module in attn_proc.named_modules():
               if layer_name.endswith("_lora"):
                    a											=   (
                        torch.randn_like(layer_module.up.weight)
                        if randn_weight
                        else torch.zeros_like(layer_module.up.weight)
                    )
                    a											=   torch.nn.Parameter(__UpperCamelCase)





class     a__ (      unittest.TestCase   ):







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



          '''simple docstring'''



          torch.manual_seed(0				)
          a											=   UNetaDConditionModel(
              block_out_channels=(32, 64)						,	layers_per_block=2						,	sample_size=32						,	in_channels=4						,	out_channels=4						,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")						,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")						,	cross_attention_dim=32						,	)
          a											=   DDIMScheduler(
              beta_start=0.0_0_0_8_5						,	beta_end=0.0_1_2						,	beta_schedule="scaled_linear"						,	clip_sample=A						,	set_alpha_to_one=A						,	steps_offset=1						,	)
          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						,	)
          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						,	)
          a											=   CLIPTextModel(A				)
          a											=   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

          a						,   a											=   create_unet_lora_layers(A				)
          a											=   create_text_encoder_lora_layers(A				)

          a											=   {
              "unet": unet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          a											=   {
              "unet_lora_layers": unet_lora_layers,
              "text_encoder_lora_layers": text_encoder_lora_layers,
              "unet_lora_attn_procs": unet_lora_attn_procs,
          }
          return pipeline_components, lora_components







     def     lowerCAmelCase_       (			self				)						->					Optional[Any]:



          '''simple docstring'''



          a											=   1
          a											=   10
          a											=   4
          a											=   (32, 32)

          a											=   torch.manual_seed(0				)
          a											=   floats_tensor((batch_size, num_channels) + sizes				)
          a											=   torch.randint(1						,	A						,	size=(batch_size, sequence_length)						,	generator=A				)

          a											=   {
              "prompt": "A painting of a squirrel eating a burger",
              "generator": generator,
              "num_inference_steps": 2,
              "guidance_scale": 6.0,
              "output_type": "numpy",
          }

          return noise, input_ids, pipeline_inputs

          # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb







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



          '''simple docstring'''



          a											=   77

          a											=   torch.randint(2						,	56						,	size=(1, max_seq_length)						,	generator=torch.manual_seed(0				)				)

          a											=   {}
          a											=   inputs
          return prepared_inputs







     def     lowerCAmelCase_       (			self						,	A				)						->					Optional[int]:



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          LoraLoaderMixin.save_lora_weights(
              save_directory=A						,	unet_lora_layers=lora_components["unet_lora_layers"]						,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,	)
          self.assertTrue(os.path.isfile(os.path.join(A						,	"pytorch_lora_weights.bin"				)				)				)







     def     lowerCAmelCase_       (			self				)						->					Any:



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   StableDiffusionPipeline(**A				)
          a											=   sd_pipe.to(A				)
          sd_pipe.set_progress_bar_config(disable=A				)

          a						,   a						,   a											=   self.get_dummy_inputs()

          a											=   sd_pipe(**A				).images
          a											=   original_images[0, -3:, -3:, -1]

          with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=A						,	unet_lora_layers=lora_components["unet_lora_layers"]						,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,	)
               self.assertTrue(os.path.isfile(os.path.join(A						,	"pytorch_lora_weights.bin"				)				)				)
               sd_pipe.load_lora_weights(A				)

          a											=   sd_pipe(**A				).images
          a											=   lora_images[0, -3:, -3:, -1]

          # Outputs shouldn't match.
          self.assertFalse(torch.allclose(torch.from_numpy(A				)						,	torch.from_numpy(A				)				)				)







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



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   StableDiffusionPipeline(**A				)
          a											=   sd_pipe.to(A				)
          sd_pipe.set_progress_bar_config(disable=A				)

          a						,   a						,   a											=   self.get_dummy_inputs()

          a											=   sd_pipe(**A				).images
          a											=   original_images[0, -3:, -3:, -1]

          with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=A						,	unet_lora_layers=lora_components["unet_lora_layers"]						,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,	safe_serialization=A						,	)
               self.assertTrue(os.path.isfile(os.path.join(A						,	"pytorch_lora_weights.safetensors"				)				)				)
               sd_pipe.load_lora_weights(A				)

          a											=   sd_pipe(**A				).images
          a											=   lora_images[0, -3:, -3:, -1]

          # Outputs shouldn't match.
          self.assertFalse(torch.allclose(torch.from_numpy(A				)						,	torch.from_numpy(A				)				)				)







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



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   lora_components["unet_lora_attn_procs"]
          a											=   StableDiffusionPipeline(**A				)
          a											=   sd_pipe.to(A				)
          sd_pipe.set_progress_bar_config(disable=A				)

          a						,   a						,   a											=   self.get_dummy_inputs()

          a											=   sd_pipe(**A				).images
          a											=   original_images[0, -3:, -3:, -1]

          with tempfile.TemporaryDirectory() as tmpdirname:
               a											=   sd_pipe.unet
               unet.set_attn_processor(A				)
               unet.save_attn_procs(A				)
               self.assertTrue(os.path.isfile(os.path.join(A						,	"pytorch_lora_weights.bin"				)				)				)
               sd_pipe.load_lora_weights(A				)

          a											=   sd_pipe(**A				).images
          a											=   lora_images[0, -3:, -3:, -1]

          # Outputs shouldn't match.
          self.assertFalse(torch.allclose(torch.from_numpy(A				)						,	torch.from_numpy(A				)				)				)







     def     lowerCAmelCase_       (			self				)						->					Optional[Any]:



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   StableDiffusionPipeline(**A				)

          a											=   self.get_dummy_tokens()

          # inference without lora
          a											=   pipe.text_encoder(**A				)[0]
          assert outputs_without_lora.shape == (1, 77, 32)

          # create lora_attn_procs with zeroed out up.weights
          a											=   create_text_encoder_lora_attn_procs(pipe.text_encoder				)
          set_lora_up_weights(A						,	randn_weight=A				)

          # monkey patch
          pipe._modify_text_encoder(A				)

          # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
          del text_attn_procs
          gc.collect()

          # inference with lora
          a											=   pipe.text_encoder(**A				)[0]
          assert outputs_with_lora.shape == (1, 77, 32)

          assert torch.allclose(
              A						,	A				), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

          # create lora_attn_procs with randn up.weights
          a											=   create_text_encoder_lora_attn_procs(pipe.text_encoder				)
          set_lora_up_weights(A						,	randn_weight=A				)

          # monkey patch
          pipe._modify_text_encoder(A				)

          # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
          del text_attn_procs
          gc.collect()

          # inference with lora
          a											=   pipe.text_encoder(**A				)[0]
          assert outputs_with_lora.shape == (1, 77, 32)

          assert not torch.allclose(
              A						,	A				), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"







     def     lowerCAmelCase_       (			self				)						->					Any:



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   StableDiffusionPipeline(**A				)

          a											=   self.get_dummy_tokens()

          # inference without lora
          a											=   pipe.text_encoder(**A				)[0]
          assert outputs_without_lora.shape == (1, 77, 32)

          # create lora_attn_procs with randn up.weights
          a											=   create_text_encoder_lora_attn_procs(pipe.text_encoder				)
          set_lora_up_weights(A						,	randn_weight=A				)

          # monkey patch
          pipe._modify_text_encoder(A				)

          # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
          del text_attn_procs
          gc.collect()

          # inference with lora
          a											=   pipe.text_encoder(**A				)[0]
          assert outputs_with_lora.shape == (1, 77, 32)

          assert not torch.allclose(
              A						,	A				), "lora outputs should be different to without lora outputs"

          # remove monkey patch
          pipe._remove_text_encoder_monkey_patch()

          # inference with removed lora
          a											=   pipe.text_encoder(**A				)[0]
          assert outputs_without_lora_removed.shape == (1, 77, 32)

          assert torch.allclose(
              A						,	A				), "remove lora monkey patch should restore the original outputs"







     def     lowerCAmelCase_       (			self				)						->					str:



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   StableDiffusionPipeline(**A				)
          a											=   sd_pipe.to(A				)
          sd_pipe.set_progress_bar_config(disable=A				)

          a						,   a						,   a											=   self.get_dummy_inputs()

          with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=A						,	unet_lora_layers=lora_components["unet_lora_layers"]						,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,	)
               self.assertTrue(os.path.isfile(os.path.join(A						,	"pytorch_lora_weights.bin"				)				)				)
               sd_pipe.load_lora_weights(A				)

          a											=   sd_pipe(**A				).images
          a											=   lora_images[0, -3:, -3:, -1]

          a											=   sd_pipe(**A						,	cross_attention_kwargs={"scale": 0.5}				).images
          a											=   lora_images_with_scale[0, -3:, -3:, -1]

          # Outputs shouldn't match.
          self.assertFalse(
              torch.allclose(torch.from_numpy(A				)						,	torch.from_numpy(A				)				)				)







     def     lowerCAmelCase_       (			self				)						->					Optional[Any]:



          '''simple docstring'''



          with tempfile.TemporaryDirectory() as tmpdirname:
               self.create_lora_weight_file(A				)

               a						,   a											=   self.get_dummy_components()
               a											=   StableDiffusionPipeline(**A				)
               a											=   sd_pipe.to(A				)
               sd_pipe.set_progress_bar_config(disable=A				)

               # check if vanilla attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                    if isinstance(A						,	A				):
                         self.assertIsInstance(module.processor						,	(AttnProcessor, AttnProcessor2_0)				)

            # load LoRA weight file
               sd_pipe.load_lora_weights(A				)

               # check if lora attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                    if isinstance(A						,	A				):
                         a											=   (
                             LoRAAttnProcessor2_0 if hasattr(A						,	"scaled_dot_product_attention"				) else LoRAAttnProcessor
                         )
                         self.assertIsInstance(module.processor						,	A				)







     @unittest.skipIf(torch_device != "cuda"						,	"This test is supposed to run on GPU"				)
     def     lowerCAmelCase_       (			self				)						->					Union[str, Any]:



          '''simple docstring'''



          with tempfile.TemporaryDirectory() as tmpdirname:
               self.create_lora_weight_file(A				)

               a						,   a											=   self.get_dummy_components()
               a											=   StableDiffusionPipeline(**A				)
               a											=   sd_pipe.to(A				)
               sd_pipe.set_progress_bar_config(disable=A				)

               # enable XFormers
               sd_pipe.enable_xformers_memory_efficient_attention()

               # check if xFormers attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                    if isinstance(A						,	A				):
                         self.assertIsInstance(module.processor						,	A				)

            # load LoRA weight file
               sd_pipe.load_lora_weights(A				)

               # check if lora attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                    if isinstance(A						,	A				):
                         self.assertIsInstance(module.processor						,	A				)







     @unittest.skipIf(torch_device != "cuda"						,	"This test is supposed to run on GPU"				)
     def     lowerCAmelCase_       (			self				)						->					int:



          '''simple docstring'''



          a						,   a											=   self.get_dummy_components()
          a											=   StableDiffusionPipeline(**A				)
          a											=   sd_pipe.to(A				)
          sd_pipe.set_progress_bar_config(disable=A				)

          a						,   a						,   a											=   self.get_dummy_inputs()

          # enable XFormers
          sd_pipe.enable_xformers_memory_efficient_attention()

          a											=   sd_pipe(**A				).images
          a											=   original_images[0, -3:, -3:, -1]

          with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=A						,	unet_lora_layers=lora_components["unet_lora_layers"]						,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,	)
               self.assertTrue(os.path.isfile(os.path.join(A						,	"pytorch_lora_weights.bin"				)				)				)
               sd_pipe.load_lora_weights(A				)

          a											=   sd_pipe(**A				).images
          a											=   lora_images[0, -3:, -3:, -1]

          # Outputs shouldn't match.
          self.assertFalse(torch.allclose(torch.from_numpy(A				)						,	torch.from_numpy(A				)				)				)

