




"""simple docstring"""

import unittest

from transformers import SpeechaTextaConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers.models.speech_to_text_a.modeling_speech_to_text_a import (
		    SpeechaTextaDecoder,
		    SpeechaTextaForCausalLM,
		)

@require_torch
class 							lowercase   :







				def __init__(				self :       Dict   ,  _lowerCamelCase :       Optional[int]   ,  _lowerCamelCase :       List[Any]=99   ,  _lowerCamelCase :       Optional[int]=13   ,  _lowerCamelCase :       Dict=16   ,  _lowerCamelCase :       int=7   ,  _lowerCamelCase :       List[Any]=True   ,  _lowerCamelCase :       Optional[int]=True   ,  _lowerCamelCase :       Optional[int]=True   ,  _lowerCamelCase :       int=False   ,  _lowerCamelCase :       Dict=True   ,  _lowerCamelCase :       Tuple=2   ,  _lowerCamelCase :       Optional[Any]=32   ,  _lowerCamelCase :       Union[str, Any]=4   ,  _lowerCamelCase :       Tuple=4   ,  _lowerCamelCase :       Tuple=30   ,  _lowerCamelCase :       Dict=0   ,  _lowerCamelCase :       Any=1   ,  _lowerCamelCase :       str=2   ,  _lowerCamelCase :       Union[str, Any]=None   ,  ):



					"""simple docstring"""

					A_	:					Optional[Any]						 =		parent
					A_	:					Optional[Any]						 =		batch_size
					A_	:					int						 =		decoder_seq_length
					# For common tests
					A_	:					List[Any]						 =		self.decoder_seq_length
					A_	:					Optional[int]						 =		is_training
					A_	:					Optional[Any]						 =		use_attention_mask
					A_	:					List[Any]						 =		use_labels

					A_	:					Tuple						 =		vocab_size
					A_	:					int						 =		d_model
					A_	:					Tuple						 =		d_model
					A_	:					Optional[Any]						 =		decoder_layers
					A_	:					List[str]						 =		decoder_layers
					A_	:					Optional[int]						 =		decoder_ffn_dim
					A_	:					Dict						 =		decoder_attention_heads
					A_	:					str						 =		decoder_attention_heads
					A_	:					List[Any]						 =		eos_token_id
					A_	:					Optional[int]						 =		bos_token_id
					A_	:					int						 =		pad_token_id
					A_	:					List[str]						 =		decoder_start_token_id
					A_	:					int						 =		use_cache
					A_	:					int						 =		max_position_embeddings

					A_	:					int						 =		None
					A_	:					str						 =		decoder_seq_length
					A_	:					List[str]						 =		2
					A_	:					Any						 =		1







				def        a_	(				self :       Any							):



					"""simple docstring"""

					A_	:					Any						 =		ids_tensor([self.batch_size, self.decoder_seq_length]   ,  self.vocab_size							)

					A_	:					List[str]						 =		None
					if self.use_attention_mask:
						A_	:					Any						 =		ids_tensor([self.batch_size, self.decoder_seq_length]   ,  vocab_size=2							)

					A_	:					Any						 =		None
					if self.use_labels:
						A_	:					Optional[Any]						 =		ids_tensor([self.batch_size, self.decoder_seq_length]   ,  self.vocab_size							)

					A_	:					Dict						 =		SpeechaTextaConfig(
					    vocab_size=self.vocab_size   ,  d_model=self.d_model   ,  decoder_layers=self.decoder_layers   ,  decoder_ffn_dim=self.decoder_ffn_dim   ,  decoder_attention_heads=self.decoder_attention_heads   ,  eos_token_id=self.eos_token_id   ,  bos_token_id=self.bos_token_id   ,  use_cache=self.use_cache   ,  pad_token_id=self.pad_token_id   ,  decoder_start_token_id=self.decoder_start_token_id   ,  max_position_embeddings=self.max_position_embeddings   ,  )

					return (
					    config,
					    input_ids,
					    attention_mask,
					    lm_labels,
					)







				def        a_	(				self :       int   ,  _lowerCamelCase :       Dict   ,  _lowerCamelCase :       str   ,  _lowerCamelCase :       str   ,  _lowerCamelCase :       Optional[int]   ,  ):



					"""simple docstring"""

					A_	:					List[Any]						 =		True
					A_	:					int						 =		SpeechaTextaDecoder(config=_lowerCamelCase							).to(_lowerCamelCase							).eval()
					A_	:					Dict						 =		input_ids[:2]

					input_ids[input_ids == 0] += 1
					# first forward pass
					A_	:					str						 =		model(_lowerCamelCase   ,  use_cache=_lowerCamelCase							)
					A_	:					Optional[int]						 =		model(_lowerCamelCase							)
					A_	:					Dict						 =		model(_lowerCamelCase   ,  use_cache=_lowerCamelCase							)

					self.parent.assertTrue(len(_lowerCamelCase							) == len(_lowerCamelCase							)							)
					self.parent.assertTrue(len(_lowerCamelCase							) == len(_lowerCamelCase							) + 1							)

					A_	:					str						 =		outputs['''past_key_values''']

					# create hypothetical next token and extent to next_input_ids
					A_	:					Dict						 =		ids_tensor((2, 1)   ,  config.vocab_size - 1							) + 1

					# append to next input_ids and
					A_	:					Dict						 =		torch.cat([input_ids, next_tokens]   ,  dim=-1							)

					print(_lowerCamelCase							)

					A_	:					List[str]						 =		model(_lowerCamelCase							)['''last_hidden_state''']
					A_	:					List[Any]						 =		model(_lowerCamelCase   ,  past_key_values=_lowerCamelCase							)['''last_hidden_state''']

					# select random slice
					A_	:					Tuple						 =		ids_tensor((1,)   ,  output_from_past.shape[-1]							).item()
					A_	:					str						 =		output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
					A_	:					int						 =		output_from_past[:, 0, random_slice_idx].detach()

					# test that outputs are equal for slice
					assert torch.allclose(_lowerCamelCase   ,  _lowerCamelCase   ,  atol=1E-3							)







				def        a_	(				self :       List[str]							):



					"""simple docstring"""

					A_	:					Any						 =		self.prepare_config_and_inputs()
					(
					    (
					    A_
					) ,			(
					    A_
					) ,			(
					    A_
					) ,			(
					    A_
					) ,			
					)	:					Optional[int]						 =		config_and_inputs

					A_	:					Union[str, Any]						 =		{
					    '''input_ids''': input_ids,
					    '''attention_mask''': attention_mask,
					}
					return config, inputs_dict

@require_torch
class 							lowercase   (     __UpperCAmelCase  ,						__UpperCAmelCase  ,						__UpperCAmelCase  ,						unittest.TestCase):
				__lowerCAmelCase     :     Optional[int]								= (SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
				__lowerCAmelCase     :     Union[str, Any]								= (SpeechaTextaForCausalLM,) if is_torch_available() else ()
				__lowerCAmelCase     :     Optional[Any]								= {"""text-generation""": SpeechaTextaForCausalLM} if is_torch_available() else {}
				__lowerCAmelCase     :     Optional[Any]								= True
				__lowerCAmelCase     :     List[str]								= False







				def        a_	(				self :       Union[str, Any]   ,  ):



					"""simple docstring"""

					A_	:					Union[str, Any]						 =		SpeechaTextaStandaloneDecoderModelTester(self   ,  is_training=_lowerCamelCase							)
					A_	:					Any						 =		ConfigTester(self   ,  config_class=_lowerCamelCase							)







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					pass







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					pass







				def        a_	(				self :       Union[str, Any]							):



					"""simple docstring"""

					pass







				def        a_	(				self :       int							):



					"""simple docstring"""

					self.config_tester.run_common_tests()







				def        a_	(				self :       Optional[Any]							):



					"""simple docstring"""

					A_	:					Optional[int]						 =		self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_decoder_model_past(*_lowerCamelCase							)







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					return











"""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						):




	"""simple docstring"""






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

def 		lowercase_   (		_UpperCAmelCase						):




	"""simple docstring"""






	A_	:					Union[str, Any]						 =		{}
	A_	:					List[str]						 =		(
	    LoRAAttnProcessor2_0 if hasattr(_UpperCAmelCase	,   '''scaled_dot_product_attention'''						) else LoRAAttnProcessor
	)
	for name, module in text_encoder.named_modules():
		if name.endswith(_UpperCAmelCase						):
			A_	:					Optional[int]						 =		lora_attn_processor_class(
			    hidden_size=module.out_proj.out_features	,   cross_attention_dim=_UpperCAmelCase						)
	return text_lora_attn_procs

def 		lowercase_   (		_UpperCAmelCase						):




	"""simple docstring"""






	A_	:					Optional[Any]						 =		create_text_encoder_lora_attn_procs(_UpperCAmelCase						)
	A_	:					List[str]						 =		AttnProcsLayers(_UpperCAmelCase						)
	return text_encoder_lora_layers

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase=False						):




	"""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'''						):
				A_	:					List[Any]						 =		(
				    torch.randn_like(layer_module.up.weight						)
				    if randn_weight
				    else torch.zeros_like(layer_module.up.weight						)
				)
				A_	:					Tuple						 =		torch.nn.Parameter(_UpperCAmelCase						)

class 							lowercase   (     unittest.TestCase):







				def        a_	(				self :       List[Any]							):



					"""simple docstring"""

					torch.manual_seed(0							)
					A_	:					List[str]						 =		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_	:					Optional[int]						 =		DDIMScheduler(
					    beta_start=0.00085   ,  beta_end=0.012   ,  beta_schedule='''scaled_linear'''   ,  clip_sample=_lowerCamelCase   ,  set_alpha_to_one=_lowerCamelCase   ,  steps_offset=1   ,  )
					torch.manual_seed(0							)
					A_	:					Any						 =		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_	:					Union[str, Any]						 =		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=10_00   ,  )
					A_	:					List[Any]						 =		CLIPTextModel(_lowerCamelCase							)
					A_	:					str						 =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

					A_ ,			A_	:					Any						 =		create_unet_lora_layers(_lowerCamelCase							)
					A_	:					Tuple						 =		create_text_encoder_lora_layers(_lowerCamelCase							)

					A_	:					Any						 =		{
					    '''unet''': unet,
					    '''scheduler''': scheduler,
					    '''vae''': vae,
					    '''text_encoder''': text_encoder,
					    '''tokenizer''': tokenizer,
					    '''safety_checker''': None,
					    '''feature_extractor''': None,
					}
					A_	:					Union[str, Any]						 =		{
					    '''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 :       str							):



					"""simple docstring"""

					A_	:					Optional[int]						 =		1
					A_	:					Tuple						 =		10
					A_	:					int						 =		4
					A_	:					List[Any]						 =		(32, 32)

					A_	:					str						 =		torch.manual_seed(0							)
					A_	:					Dict						 =		floats_tensor((batch_size, num_channels) + sizes							)
					A_	:					List[str]						 =		torch.randint(1   ,  _lowerCamelCase   ,  size=(batch_size, sequence_length)   ,  generator=_lowerCamelCase							)

					A_	:					int						 =		{
					    '''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 :       str							):



					"""simple docstring"""

					A_	:					Union[str, Any]						 =		77

					A_	:					str						 =		torch.randint(2   ,  56   ,  size=(1, max_seq_length)   ,  generator=torch.manual_seed(0							)							)

					A_	:					Optional[Any]						 =		{}
					A_	:					int						 =		inputs
					return prepared_inputs







				def        a_	(				self :       Optional[int]   ,  _lowerCamelCase :       List[Any]							):



					"""simple docstring"""

					A_ ,			A_	:					List[str]						 =		self.get_dummy_components()
					LoraLoaderMixin.save_lora_weights(
					    save_directory=_lowerCamelCase   ,  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(_lowerCamelCase   ,  '''pytorch_lora_weights.bin'''							)							)							)







				def        a_	(				self :       Any							):



					"""simple docstring"""

					A_ ,			A_	:					Optional[Any]						 =		self.get_dummy_components()
					A_	:					List[str]						 =		StableDiffusionPipeline(**_lowerCamelCase							)
					A_	:					List[str]						 =		sd_pipe.to(_lowerCamelCase							)
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

					A_ ,			A_ ,			A_	:					str						 =		self.get_dummy_inputs()

					A_	:					Optional[int]						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					str						 =		original_images[0, -3:, -3:, -1]

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

					A_	:					List[Any]						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					str						 =		lora_images[0, -3:, -3:, -1]

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







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					A_ ,			A_	:					List[Any]						 =		self.get_dummy_components()
					A_	:					str						 =		StableDiffusionPipeline(**_lowerCamelCase							)
					A_	:					Any						 =		sd_pipe.to(_lowerCamelCase							)
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

					A_ ,			A_ ,			A_	:					List[str]						 =		self.get_dummy_inputs()

					A_	:					Union[str, Any]						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					int						 =		original_images[0, -3:, -3:, -1]

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

					A_	:					Union[str, Any]						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					Dict						 =		lora_images[0, -3:, -3:, -1]

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







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					A_ ,			A_	:					List[Any]						 =		self.get_dummy_components()
					A_	:					Any						 =		lora_components['''unet_lora_attn_procs''']
					A_	:					Any						 =		StableDiffusionPipeline(**_lowerCamelCase							)
					A_	:					Tuple						 =		sd_pipe.to(_lowerCamelCase							)
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

					A_ ,			A_ ,			A_	:					Tuple						 =		self.get_dummy_inputs()

					A_	:					Tuple						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					Optional[Any]						 =		original_images[0, -3:, -3:, -1]

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

					A_	:					Any						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					Optional[int]						 =		lora_images[0, -3:, -3:, -1]

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







				def        a_	(				self :       Tuple							):



					"""simple docstring"""

					A_ ,			A_	:					List[str]						 =		self.get_dummy_components()
					A_	:					Dict						 =		StableDiffusionPipeline(**_lowerCamelCase							)

					A_	:					Any						 =		self.get_dummy_tokens()

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

					# create lora_attn_procs with zeroed out up.weights
					A_	:					str						 =		create_text_encoder_lora_attn_procs(pipe.text_encoder							)
					set_lora_up_weights(_lowerCamelCase   ,  randn_weight=_lowerCamelCase							)

					# monkey patch
					pipe._modify_text_encoder(_lowerCamelCase							)

					# 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_	:					List[str]						 =		pipe.text_encoder(**_lowerCamelCase							)[0]
					assert outputs_with_lora.shape == (1, 77, 32)

					assert torch.allclose(
					    _lowerCamelCase   ,  _lowerCamelCase							), "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_	:					Tuple						 =		create_text_encoder_lora_attn_procs(pipe.text_encoder							)
					set_lora_up_weights(_lowerCamelCase   ,  randn_weight=_lowerCamelCase							)

					# monkey patch
					pipe._modify_text_encoder(_lowerCamelCase							)

					# 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_	:					str						 =		pipe.text_encoder(**_lowerCamelCase							)[0]
					assert outputs_with_lora.shape == (1, 77, 32)

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







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					A_ ,			A_	:					List[Any]						 =		self.get_dummy_components()
					A_	:					Optional[int]						 =		StableDiffusionPipeline(**_lowerCamelCase							)

					A_	:					List[Any]						 =		self.get_dummy_tokens()

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

					# create lora_attn_procs with randn up.weights
					A_	:					List[Any]						 =		create_text_encoder_lora_attn_procs(pipe.text_encoder							)
					set_lora_up_weights(_lowerCamelCase   ,  randn_weight=_lowerCamelCase							)

					# monkey patch
					pipe._modify_text_encoder(_lowerCamelCase							)

					# 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_	:					List[Any]						 =		pipe.text_encoder(**_lowerCamelCase							)[0]
					assert outputs_with_lora.shape == (1, 77, 32)

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

					# remove monkey patch
					pipe._remove_text_encoder_monkey_patch()

					# inference with removed lora
					A_	:					Optional[int]						 =		pipe.text_encoder(**_lowerCamelCase							)[0]
					assert outputs_without_lora_removed.shape == (1, 77, 32)

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







				def        a_	(				self :       Tuple							):



					"""simple docstring"""

					A_ ,			A_	:					Dict						 =		self.get_dummy_components()
					A_	:					str						 =		StableDiffusionPipeline(**_lowerCamelCase							)
					A_	:					Dict						 =		sd_pipe.to(_lowerCamelCase							)
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

					A_ ,			A_ ,			A_	:					Tuple						 =		self.get_dummy_inputs()

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

					A_	:					Dict						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					Union[str, Any]						 =		lora_images[0, -3:, -3:, -1]

					A_	:					int						 =		sd_pipe(**_lowerCamelCase   ,  cross_attention_kwargs={'''scale''': 0.5}							).images
					A_	:					int						 =		lora_images_with_scale[0, -3:, -3:, -1]

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







				def        a_	(				self :       Tuple							):



					"""simple docstring"""

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

						A_ ,			A_	:					str						 =		self.get_dummy_components()
						A_	:					Optional[Any]						 =		StableDiffusionPipeline(**_lowerCamelCase							)
						A_	:					List[Any]						 =		sd_pipe.to(_lowerCamelCase							)
						sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

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

            # load LoRA weight file
						sd_pipe.load_lora_weights(_lowerCamelCase							)

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







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



					"""simple docstring"""

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

						A_ ,			A_	:					Tuple						 =		self.get_dummy_components()
						A_	:					Optional[int]						 =		StableDiffusionPipeline(**_lowerCamelCase							)
						A_	:					Any						 =		sd_pipe.to(_lowerCamelCase							)
						sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

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

            # load LoRA weight file
						sd_pipe.load_lora_weights(_lowerCamelCase							)

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







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



					"""simple docstring"""

					A_ ,			A_	:					Any						 =		self.get_dummy_components()
					A_	:					Union[str, Any]						 =		StableDiffusionPipeline(**_lowerCamelCase							)
					A_	:					Optional[int]						 =		sd_pipe.to(_lowerCamelCase							)
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase							)

					A_ ,			A_ ,			A_	:					int						 =		self.get_dummy_inputs()

					# enable XFormers
					sd_pipe.enable_xformers_memory_efficient_attention()

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

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

					A_	:					List[Any]						 =		sd_pipe(**_lowerCamelCase							).images
					A_	:					int						 =		lora_images[0, -3:, -3:, -1]

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





