





'''simple docstring'''



import collections
import inspect
import unittest

from transformers import DinatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
			import torch
			from torch import nn

			from transformers import DinatBackbone, DinatForImageClassification, DinatModel
			from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor

class     A_ :

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_=13			,     A_=64			,     A_=4			,     A_=3			,     A_=16			,     A_=[1, 2, 1]			,     A_=[2, 4, 8]			,     A_=3			,     A_=[[3], [1, 2], [1]]			,     A_=2.0			,     A_=True			,     A_=0.0			,     A_=0.0			,     A_=0.1			,     A_="gelu"			,     A_=True			,     A_=0.02			,     A_=1e-5			,     A_=True			,     A_=None			,     A_=True			,     A_=10			,     A_=["stage1", "stage2"]			,     A_=[1, 2]			,     ):
								_UpperCamelCase											=   parent
								_UpperCamelCase											=   batch_size
								_UpperCamelCase											=   image_size
								_UpperCamelCase											=   patch_size
								_UpperCamelCase											=   num_channels
								_UpperCamelCase											=   embed_dim
								_UpperCamelCase											=   depths
								_UpperCamelCase											=   num_heads
								_UpperCamelCase											=   kernel_size
								_UpperCamelCase											=   dilations
								_UpperCamelCase											=   mlp_ratio
								_UpperCamelCase											=   qkv_bias
								_UpperCamelCase											=   hidden_dropout_prob
								_UpperCamelCase											=   attention_probs_dropout_prob
								_UpperCamelCase											=   drop_path_rate
								_UpperCamelCase											=   hidden_act
								_UpperCamelCase											=   patch_norm
								_UpperCamelCase											=   layer_norm_eps
								_UpperCamelCase											=   initializer_range
								_UpperCamelCase											=   is_training
								_UpperCamelCase											=   scope
								_UpperCamelCase											=   use_labels
								_UpperCamelCase											=   num_labels
								_UpperCamelCase											=   out_features
								_UpperCamelCase											=   out_indices




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

								_UpperCamelCase											=   None
								if self.use_labels:
													_UpperCamelCase											=   ids_tensor([self.batch_size]			,     self.num_labels   )

								_UpperCamelCase											=   self.get_config()

								return config, pixel_values, labels




			def       a	(					self   ):
								return DinatConfig(
								    num_labels=self.num_labels			,     image_size=self.image_size			,     patch_size=self.patch_size			,     num_channels=self.num_channels			,     embed_dim=self.embed_dim			,     depths=self.depths			,     num_heads=self.num_heads			,     kernel_size=self.kernel_size			,     dilations=self.dilations			,     mlp_ratio=self.mlp_ratio			,     qkv_bias=self.qkv_bias			,     hidden_dropout_prob=self.hidden_dropout_prob			,     attention_probs_dropout_prob=self.attention_probs_dropout_prob			,     drop_path_rate=self.drop_path_rate			,     hidden_act=self.hidden_act			,     patch_norm=self.patch_norm			,     layer_norm_eps=self.layer_norm_eps			,     initializer_range=self.initializer_range			,     out_features=self.out_features			,     out_indices=self.out_indices			,     )




			def       a	(					self			,     A_			,     A_			,     A_   ):
								_UpperCamelCase											=   DinatModel(config=A_   )
								model.to(A_   )
								model.eval()
								_UpperCamelCase											=   model(A_   )

								_UpperCamelCase											=   _UpperCamelCase											=   (config.image_size // config.patch_size) // (2 ** (len(config.depths   ) - 1))
								_UpperCamelCase											=   int(config.embed_dim * 2 ** (len(config.depths   ) - 1)   )

								self.parent.assertEqual(
								    result.last_hidden_state.shape			,     (self.batch_size, expected_height, expected_width, expected_dim)   )




			def       a	(					self			,     A_			,     A_			,     A_   ):
								_UpperCamelCase											=   DinatForImageClassification(A_   )
								model.to(A_   )
								model.eval()
								_UpperCamelCase											=   model(A_			,     labels=A_   )
								self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)   )

								# test greyscale images
								_UpperCamelCase											=   1
								_UpperCamelCase											=   DinatForImageClassification(A_   )
								model.to(A_   )
								model.eval()

								_UpperCamelCase											=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
								_UpperCamelCase											=   model(A_   )
								self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)   )




			def       a	(					self			,     A_			,     A_			,     A_   ):
								_UpperCamelCase											=   DinatBackbone(config=A_   )
								model.to(A_   )
								model.eval()
								_UpperCamelCase											=   model(A_   )

								# verify hidden states
								self.parent.assertEqual(len(result.feature_maps   )			,     len(config.out_features   )   )
								self.parent.assertListEqual(list(result.feature_maps[0].shape   )			,     [self.batch_size, model.channels[0], 16, 16]   )

								# verify channels
								self.parent.assertEqual(len(model.channels   )			,     len(config.out_features   )   )

								# verify backbone works with out_features=None
								_UpperCamelCase											=   None
								_UpperCamelCase											=   DinatBackbone(config=A_   )
								model.to(A_   )
								model.eval()
								_UpperCamelCase											=   model(A_   )

								# verify feature maps
								self.parent.assertEqual(len(result.feature_maps   )			,     1   )
								self.parent.assertListEqual(list(result.feature_maps[0].shape   )			,     [self.batch_size, model.channels[-1], 4, 4]   )

								# verify channels
								self.parent.assertEqual(len(model.channels   )			,     1   )




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




@require_natten
@require_torch
class     A_ (  lowerCAmelCase_    ,			lowerCAmelCase_    ,			unittest.TestCase  ):

			'''simple docstring'''





			_lowerCAmelCase						=    (
			    (
			        DinatModel,
			        DinatForImageClassification,
			        DinatBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowerCAmelCase						=    (
			    {"""feature-extraction""": DinatModel, """image-classification""": DinatForImageClassification}
			    if is_torch_available()
			    else {}
			)
			_lowerCAmelCase						=    False

			_lowerCAmelCase						=    False
			_lowerCAmelCase						=    False
			_lowerCAmelCase						=    False
			_lowerCAmelCase						=    False




			def       a	(					self   ):
								_UpperCamelCase											=   DinatModelTester(self   )
								_UpperCamelCase											=   ConfigTester(self			,     config_class=A_			,     embed_dim=37   )




			def       a	(					self   ):
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()




			def       a	(					self   ):
								return




			def       a	(					self   ):
								_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*A_   )




			def       a	(					self   ):
								_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*A_   )




			def       a	(					self   ):
								_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*A_   )




			@unittest.skip(reason="Dinat does not use inputs_embeds"   )
			def       a	(					self   ):
								pass




			@unittest.skip(reason="Dinat does not use feedforward chunking"   )
			def       a	(					self   ):
								pass




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													_UpperCamelCase											=   model_class(A_   )
													self.assertIsInstance(model.get_input_embeddings()			,     (nn.Module)   )
													_UpperCamelCase											=   model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(A_			,     nn.Linear   )   )




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs_for_common()

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

													_UpperCamelCase											=   ["pixel_values"]
													self.assertListEqual(arg_names[:1]			,     A_   )




			def       a	(					self   ):
								self.skipTest("Dinat's attention operation is handled entirely by NATTEN."   )




			def       a	(					self			,     A_			,     A_			,     A_			,     A_   ):
								_UpperCamelCase											=   model_class(A_   )
								model.to(A_   )
								model.eval()

								with torch.no_grad():
													_UpperCamelCase											=   model(**self._prepare_for_class(A_			,     A_   )   )

								_UpperCamelCase											=   outputs.hidden_states

								_UpperCamelCase											=   getattr(
								    self.model_tester			,     "expected_num_hidden_layers"			,     len(self.model_tester.depths   ) + 1   )
								self.assertEqual(len(A_   )			,     A_   )

								# Dinat has a different seq_length
								_UpperCamelCase											=   (
								    config.patch_size
								    if isinstance(config.patch_size			,     collections.abc.Iterable   )
								    else (config.patch_size, config.patch_size)
								)

								_UpperCamelCase											=   image_size[0] // patch_size[0]
								_UpperCamelCase											=   image_size[1] // patch_size[1]

								self.assertListEqual(
								    list(hidden_states[0].shape[-3:]   )			,     [height, width, self.model_tester.embed_dim]			,     )

								if model_class.__name__ != "DinatBackbone":
													_UpperCamelCase											=   outputs.reshaped_hidden_states
													self.assertEqual(len(A_   )			,     A_   )

													_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   reshaped_hidden_states[0].shape
													_UpperCamelCase											=   (
													    reshaped_hidden_states[0].view(A_			,     A_			,     A_			,     A_   ).permute(0			,     2			,     3			,     1   )
													)
													self.assertListEqual(
													    list(reshaped_hidden_states.shape[-3:]   )			,     [height, width, self.model_tester.embed_dim]			,     )




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs_for_common()

								_UpperCamelCase											=   (
								    self.model_tester.image_size
								    if isinstance(self.model_tester.image_size			,     collections.abc.Iterable   )
								    else (self.model_tester.image_size, self.model_tester.image_size)
								)

								for model_class in self.all_model_classes:
													_UpperCamelCase											=   True
													self.check_hidden_states_output(A_			,     A_			,     A_			,     A_   )

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

													self.check_hidden_states_output(A_			,     A_			,     A_			,     A_   )




			@slow
			def       a	(					self   ):
								for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCamelCase											=   DinatModel.from_pretrained(A_   )
													self.assertIsNotNone(A_   )




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.model_tester.prepare_config_and_inputs_for_common()

								_UpperCamelCase											=   _config_zero_init(A_   )
								for model_class in self.all_model_classes:
													_UpperCamelCase											=   model_class(config=A_   )
													for name, param in model.named_parameters():
																		if "embeddings" not in name and param.requires_grad:
																							self.assertIn(
																							    ((param.data.mean() * 1e9).round() / 1e9).item()			,     [0.0, 1.0]			,     msg=F"Parameter {name} of model {model_class} seems not properly initialized"			,     )




@require_natten
@require_vision
@require_torch
class     A_ (  unittest.TestCase  ):

			'''simple docstring'''





			@cached_property
			def       a	(					self   ):
								return AutoImageProcessor.from_pretrained("shi-labs/dinat-mini-in1k-224"   ) if is_vision_available() else None




			@slow
			def       a	(					self   ):
								_UpperCamelCase											=   DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"   ).to(A_   )
								_UpperCamelCase											=   self.default_image_processor

								_UpperCamelCase											=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
								_UpperCamelCase											=   image_processor(images=A_			,     return_tensors="pt"   ).to(A_   )

								# forward pass
								with torch.no_grad():
													_UpperCamelCase											=   model(**A_   )

								# verify the logits
								_UpperCamelCase											=   torch.Size((1, 10_00)   )
								self.assertEqual(outputs.logits.shape			,     A_   )
								_UpperCamelCase											=   torch.tensor([-0.1545, -0.7667, 0.4642]   ).to(A_   )
								self.assertTrue(torch.allclose(outputs.logits[0, :3]			,     A_			,     atol=1e-4   )   )




@require_torch
@require_natten
class     A_ (  unittest.TestCase    ,			lowerCAmelCase_  ):

			'''simple docstring'''





			_lowerCAmelCase						=    (DinatBackbone,) if is_torch_available() else ()
			_lowerCAmelCase						=    DinatConfig




			def       a	(					self   ):
								_UpperCamelCase											=   DinatModelTester(self   )










'''simple docstring'''



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  lowercase__(		_UpperCamelCase  : nn.Module				)->   Any:






					"""simple docstring"""

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



def  lowercase__(		_UpperCamelCase  : nn.Module				)->   List[Any]:






					"""simple docstring"""

					_UpperCamelCase											=   {}
					_UpperCamelCase											=   (
					    LoRAAttnProcessor2_0 if hasattr(_UpperCamelCase ,   "scaled_dot_product_attention"				) else LoRAAttnProcessor
					)
					for name, module in text_encoder.named_modules():
										if name.endswith(_UpperCamelCase				):
															_UpperCamelCase											=   lora_attn_processor_class(
															    hidden_size=module.out_proj.out_features ,   cross_attention_dim=_UpperCamelCase				)
					return text_lora_attn_procs



def  lowercase__(		_UpperCamelCase  : nn.Module				)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   create_text_encoder_lora_attn_procs(_UpperCamelCase				)
					_UpperCamelCase											=   AttnProcsLayers(_UpperCamelCase				)
					return text_encoder_lora_layers



def  lowercase__(		_UpperCamelCase  : List[str] ,   _UpperCamelCase  : Optional[int]=False				)->   Optional[int]:






					"""simple docstring"""

					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"				):
																				_UpperCamelCase											=   (
																				    torch.randn_like(layer_module.up.weight				)
																				    if randn_weight
																				    else torch.zeros_like(layer_module.up.weight				)
																				)
																				_UpperCamelCase											=   torch.nn.Parameter(_UpperCamelCase				)

class     A_ (  unittest.TestCase  ):

			'''simple docstring'''





			def       a	(					self   ):
								torch.manual_seed(0   )
								_UpperCamelCase											=   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			,     )
								_UpperCamelCase											=   DDIMScheduler(
								    beta_start=0.0_0085			,     beta_end=0.012			,     beta_schedule="scaled_linear"			,     clip_sample=A_			,     set_alpha_to_one=A_			,     steps_offset=1			,     )
								torch.manual_seed(0   )
								_UpperCamelCase											=   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			,     )
								_UpperCamelCase											=   CLIPTextConfig(
								    bos_token_id=0			,     eos_token_id=2			,     hidden_size=32			,     intermediate_size=37			,     layer_norm_eps=1e-0_5			,     num_attention_heads=4			,     num_hidden_layers=5			,     pad_token_id=1			,     vocab_size=10_00			,     )
								_UpperCamelCase											=   CLIPTextModel(A_   )
								_UpperCamelCase											=   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )

								_UpperCamelCase				,	_UpperCamelCase											=   create_unet_lora_layers(A_   )
								_UpperCamelCase											=   create_text_encoder_lora_layers(A_   )

								_UpperCamelCase											=   {
								    "unet": unet,
								    "scheduler": scheduler,
								    "vae": vae,
								    "text_encoder": text_encoder,
								    "tokenizer": tokenizer,
								    "safety_checker": None,
								    "feature_extractor": None,
								}
								_UpperCamelCase											=   {
								    "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       a	(					self   ):
								_UpperCamelCase											=   1
								_UpperCamelCase											=   10
								_UpperCamelCase											=   4
								_UpperCamelCase											=   (32, 32)

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

								_UpperCamelCase											=   {
								    "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       a	(					self   ):
								_UpperCamelCase											=   77

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

								_UpperCamelCase											=   {}
								_UpperCamelCase											=   inputs
								return prepared_inputs




			def       a	(					self			,     A_   ):
								_UpperCamelCase				,	_UpperCamelCase											=   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       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
								_UpperCamelCase											=   sd_pipe.to(A_   )
								sd_pipe.set_progress_bar_config(disable=A_   )

								_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_inputs()

								_UpperCamelCase											=   sd_pipe(**A_   ).images
								_UpperCamelCase											=   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_   )

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

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




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
								_UpperCamelCase											=   sd_pipe.to(A_   )
								sd_pipe.set_progress_bar_config(disable=A_   )

								_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_inputs()

								_UpperCamelCase											=   sd_pipe(**A_   ).images
								_UpperCamelCase											=   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_   )

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

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




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   lora_components["unet_lora_attn_procs"]
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
								_UpperCamelCase											=   sd_pipe.to(A_   )
								sd_pipe.set_progress_bar_config(disable=A_   )

								_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_inputs()

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

								with tempfile.TemporaryDirectory() as tmpdirname:
													_UpperCamelCase											=   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_   )

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

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




			def       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )

								_UpperCamelCase											=   self.get_dummy_tokens()

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

								# create lora_attn_procs with zeroed out up.weights
								_UpperCamelCase											=   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
								_UpperCamelCase											=   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
								_UpperCamelCase											=   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
								_UpperCamelCase											=   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       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )

								_UpperCamelCase											=   self.get_dummy_tokens()

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

								# create lora_attn_procs with randn up.weights
								_UpperCamelCase											=   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
								_UpperCamelCase											=   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
								_UpperCamelCase											=   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       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
								_UpperCamelCase											=   sd_pipe.to(A_   )
								sd_pipe.set_progress_bar_config(disable=A_   )

								_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   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_   )

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

								_UpperCamelCase											=   sd_pipe(**A_			,     cross_attention_kwargs={"scale": 0.5}   ).images
								_UpperCamelCase											=   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       a	(					self   ):
								with tempfile.TemporaryDirectory() as tmpdirname:
													self.create_lora_weight_file(A_   )

													_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
													_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
													_UpperCamelCase											=   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_   ):
																							_UpperCamelCase											=   (
																							    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       a	(					self   ):
								with tempfile.TemporaryDirectory() as tmpdirname:
													self.create_lora_weight_file(A_   )

													_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
													_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
													_UpperCamelCase											=   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       a	(					self   ):
								_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_components()
								_UpperCamelCase											=   StableDiffusionPipeline(**A_   )
								_UpperCamelCase											=   sd_pipe.to(A_   )
								sd_pipe.set_progress_bar_config(disable=A_   )

								_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   self.get_dummy_inputs()

								# enable XFormers
								sd_pipe.enable_xformers_memory_efficient_attention()

								_UpperCamelCase											=   sd_pipe(**A_   ).images
								_UpperCamelCase											=   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_   )

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

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



