
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 		A_	(							snake_case							:				nn.Module	) ->      Optional[int]:



						'''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(snake_case	, '''scaled_dot_product_attention'''	) else LoRAAttnProcessor
												)
												__UpperCamelCase       					=     lora_attn_processor_class(
												    hidden_size=snake_case	, cross_attention_dim=snake_case	)
						__UpperCamelCase       					=     AttnProcsLayers(snake_case	)
						return lora_attn_procs, unet_lora_layers




def 		A_	(							snake_case							:				nn.Module	) ->      Optional[int]:



						'''simple docstring'''

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




def 		A_	(							snake_case							:				nn.Module	) ->      int:



						'''simple docstring'''

						__UpperCamelCase       					=     create_text_encoder_lora_attn_procs(snake_case	)
						__UpperCamelCase       					=     AttnProcsLayers(snake_case	)
						return text_encoder_lora_layers




def 		A_	(							snake_case							:				str	, snake_case							:				Dict=False	) ->      Dict:



						'''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(snake_case	)






class     SCREAMING_SNAKE_CASE__      (							unittest.TestCase      ):

							"""simple docstring"""






							def       A__						(					self     )->				str:





													'''simple docstring'''






													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_0_0_8_5       ,		beta_end=0.0_1_2       ,		beta_schedule='''scaled_linear'''       ,		clip_sample=SCREAMING_SNAKE_CASE_       ,		set_alpha_to_one=SCREAMING_SNAKE_CASE_       ,		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-05       ,		num_attention_heads=4       ,		num_hidden_layers=5       ,		pad_token_id=1       ,		vocab_size=1000       ,		)
													__UpperCamelCase       					=     CLIPTextModel(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     )

													__UpperCamelCase					,							__UpperCamelCase       					=     create_unet_lora_layers(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     create_text_encoder_lora_layers(SCREAMING_SNAKE_CASE_     )

													__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     )->				Any:





													'''simple docstring'''






													__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       ,		SCREAMING_SNAKE_CASE_       ,		size=(batch_size, sequence_length)       ,		generator=SCREAMING_SNAKE_CASE_     )

													__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     )->				int:





													'''simple docstring'''






													__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       ,		SCREAMING_SNAKE_CASE_     )->				int:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													LoraLoaderMixin.save_lora_weights(
													    save_directory=SCREAMING_SNAKE_CASE_       ,		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(SCREAMING_SNAKE_CASE_       ,		'''pytorch_lora_weights.bin'''     )     )     )



							def       A__						(					self     )->				Tuple:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
													sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase					,							__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_inputs()

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

													with tempfile.TemporaryDirectory() as tmpdirname:
																			LoraLoaderMixin.save_lora_weights(
																			    save_directory=SCREAMING_SNAKE_CASE_       ,		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(SCREAMING_SNAKE_CASE_       ,		'''pytorch_lora_weights.bin'''     )     )     )
																			sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE_     )

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

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



							def       A__						(					self     )->				Tuple:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
													sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase					,							__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_inputs()

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

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

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

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



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





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     lora_components['''unet_lora_attn_procs''']
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
													sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase					,							__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_inputs()

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

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

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

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



							def       A__						(					self     )->				int:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     self.get_dummy_tokens()

													# inference without lora
													__UpperCamelCase       					=     pipe.text_encoder(**SCREAMING_SNAKE_CASE_     )[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(SCREAMING_SNAKE_CASE_       ,		randn_weight=SCREAMING_SNAKE_CASE_     )

													# monkey patch
													pipe._modify_text_encoder(SCREAMING_SNAKE_CASE_     )

													# 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(**SCREAMING_SNAKE_CASE_     )[0]
													assert outputs_with_lora.shape == (1, 77, 32)

													assert torch.allclose(
													    SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     ), "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(SCREAMING_SNAKE_CASE_       ,		randn_weight=SCREAMING_SNAKE_CASE_     )

													# monkey patch
													pipe._modify_text_encoder(SCREAMING_SNAKE_CASE_     )

													# 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(**SCREAMING_SNAKE_CASE_     )[0]
													assert outputs_with_lora.shape == (1, 77, 32)

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



							def       A__						(					self     )->				Any:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     self.get_dummy_tokens()

													# inference without lora
													__UpperCamelCase       					=     pipe.text_encoder(**SCREAMING_SNAKE_CASE_     )[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(SCREAMING_SNAKE_CASE_       ,		randn_weight=SCREAMING_SNAKE_CASE_     )

													# monkey patch
													pipe._modify_text_encoder(SCREAMING_SNAKE_CASE_     )

													# 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(**SCREAMING_SNAKE_CASE_     )[0]
													assert outputs_with_lora.shape == (1, 77, 32)

													assert not torch.allclose(
													    SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     ), "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(**SCREAMING_SNAKE_CASE_     )[0]
													assert outputs_without_lora_removed.shape == (1, 77, 32)

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



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





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
													sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase					,							__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_inputs()

													with tempfile.TemporaryDirectory() as tmpdirname:
																			LoraLoaderMixin.save_lora_weights(
																			    save_directory=SCREAMING_SNAKE_CASE_       ,		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(SCREAMING_SNAKE_CASE_       ,		'''pytorch_lora_weights.bin'''     )     )     )
																			sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE_     )

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

													__UpperCamelCase       					=     sd_pipe(**SCREAMING_SNAKE_CASE_       ,		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(SCREAMING_SNAKE_CASE_     )       ,		torch.from_numpy(SCREAMING_SNAKE_CASE_     )     )     )



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





													'''simple docstring'''






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

																			__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
																			__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
																			__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
																			sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

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

            # load LoRA weight file
																			sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE_     )

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



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





													'''simple docstring'''






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

																			__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
																			__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
																			__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
																			sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

																			# 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(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     ):
																															self.assertIsInstance(module.processor       ,		SCREAMING_SNAKE_CASE_     )

            # load LoRA weight file
																			sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE_     )

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



							@unittest.skipIf(torch_device != '''cuda'''       ,		'''This test is supposed to run on GPU'''     )
							def       A__						(					self     )->				List[Any]:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_components()
													__UpperCamelCase       					=     StableDiffusionPipeline(**SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     sd_pipe.to(SCREAMING_SNAKE_CASE_     )
													sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase					,							__UpperCamelCase					,							__UpperCamelCase       					=     self.get_dummy_inputs()

													# enable XFormers
													sd_pipe.enable_xformers_memory_efficient_attention()

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

													with tempfile.TemporaryDirectory() as tmpdirname:
																			LoraLoaderMixin.save_lora_weights(
																			    save_directory=SCREAMING_SNAKE_CASE_       ,		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(SCREAMING_SNAKE_CASE_       ,		'''pytorch_lora_weights.bin'''     )     )     )
																			sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE_     )

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

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






import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig






class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							_snake_case       						=					CustomConfig



							def __init__(					self       ,		SCREAMING_SNAKE_CASE_     )->				Tuple:





													'''simple docstring'''






													super().__init__(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     torch.nn.Linear(config.hidden_size       ,		config.hidden_size     )



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





													'''simple docstring'''






													return self.linear(SCREAMING_SNAKE_CASE_     )



							def       A__						(					self       ,		SCREAMING_SNAKE_CASE_     )->				Any:





													'''simple docstring'''






													pass






class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							_snake_case       						=					NoSuperInitConfig



							def __init__(					self       ,		SCREAMING_SNAKE_CASE_     )->				Tuple:





													'''simple docstring'''






													super().__init__(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     torch.nn.Linear(config.attribute       ,		config.attribute     )



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





													'''simple docstring'''






													return self.linear(SCREAMING_SNAKE_CASE_     )



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





													'''simple docstring'''






													pass




