



'''simple docstring'''






import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
						import torch


lowerCamelCase__	  =		random.Random()





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Tuple ,       snake_case_    :     Tuple=1.0 ,       snake_case_    :     Tuple=None ,       snake_case_    :     Dict=None  )		->List[str]:






							'''simple docstring'''
							if rng is None:
														_lowercase							:		List[Any]				=   global_rng

							_lowercase							:		List[Any]				=   []
							for batch_idx in range(shape[0]  ):
														values.append([]  )
														for _ in range(shape[1]  ):
																					values[-1].append(rng.random() * scale  )

							return values

@require_torch
class 	_lowerCAmelCase     (    unittest.TestCase       ):






		'''simple docstring'''
		def __init__(						self							:       Dict      ,		UpperCamelCase_							:       Optional[Any]      ,		UpperCamelCase_							:       Optional[int]=7      ,		UpperCamelCase_							:       str=400      ,		UpperCamelCase_							:       List[str]=2_000      ,		UpperCamelCase_							:       Tuple=1      ,		UpperCamelCase_							:       Union[str, Any]=0.0      ,		UpperCamelCase_							:       Optional[int]=24_000      ,		UpperCamelCase_							:       str=True      ,		)      ->			Optional[Any]:







									'''simple docstring'''





									_lowercase							:		Optional[int]				=   parent
									_lowercase							:		List[Any]				=   batch_size
									_lowercase							:		str				=   min_seq_length
									_lowercase							:		Any				=   max_seq_length
									_lowercase							:		Optional[Any]				=   (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									_lowercase							:		List[Any]				=   feature_size
									_lowercase							:		Any				=   padding_value
									_lowercase							:		List[Any]				=   sampling_rate
									_lowercase							:		Tuple				=   return_attention_mask
		def 						__lowercase      (						self							:       List[Any]		)      ->			Union[str, Any]:







									'''simple docstring'''





									return {
									    "feature_size": self.feature_size,
									    "padding_value": self.padding_value,
									    "sampling_rate": self.sampling_rate,
									    "return_attention_mask": self.return_attention_mask,
									}





		def 						__lowercase      (						self							:       str      ,		UpperCamelCase_							:       List[Any]=False      ,		UpperCamelCase_							:       List[Any]=False		)      ->			List[str]:







									'''simple docstring'''





									def _flatten(UpperCamelCase_							:       List[Any]		):
																return list(itertools.chain(*UpperCamelCase_		)		)

									if equal_length:
																_lowercase							:		int				=   floats_list((self.batch_size, self.max_seq_length)		)
									else:
																# make sure that inputs increase in size
																_lowercase							:		int				=   [
																    _flatten(floats_list((x, self.feature_size)		)		)
																    for x in range(self.min_seq_length      ,		self.max_seq_length      ,		self.seq_length_diff		)
																]

									if numpify:
																_lowercase							:		Optional[int]				=   [np.asarray(UpperCamelCase_		) for x in audio_inputs]

									return audio_inputs




@require_torch
class 	_lowerCAmelCase     (    __A     ,		unittest.TestCase       ):






		'''simple docstring'''
		snake_case_							= EncodecFeatureExtractor
		def 						__lowercase      (						self							:       List[Any]		)      ->			List[str]:







									'''simple docstring'''





									_lowercase							:		Optional[Any]				=   EnCodecFeatureExtractionTester(self		)
		def 						__lowercase      (						self							:       int		)      ->			Optional[int]:







									'''simple docstring'''





									_lowercase							:		Dict				=   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
									# create three inputs of length 800, 1000, and 1200
									_lowercase							:		Union[str, Any]				=   [floats_list((1, x)		)[0] for x in range(800      ,		1_400      ,		200		)]
									_lowercase							:		int				=   [np.asarray(UpperCamelCase_		) for audio_input in audio_inputs]

									# Test not batched input
									_lowercase							:		Tuple				=   feat_extract(audio_inputs[0]      ,		return_tensors='''np'''		).input_values
									_lowercase							:		Any				=   feat_extract(np_audio_inputs[0]      ,		return_tensors='''np'''		).input_values
									self.assertTrue(np.allclose(UpperCamelCase_      ,		UpperCamelCase_      ,		atol=1e-3		)		)

									# Test batched
									_lowercase							:		Optional[Any]				=   feat_extract(UpperCamelCase_      ,		padding=UpperCamelCase_      ,		return_tensors='''np'''		).input_values
									_lowercase							:		List[Any]				=   feat_extract(UpperCamelCase_      ,		padding=UpperCamelCase_      ,		return_tensors='''np'''		).input_values
									for enc_seq_a, enc_seq_a in zip(UpperCamelCase_      ,		UpperCamelCase_		):
																self.assertTrue(np.allclose(UpperCamelCase_      ,		UpperCamelCase_      ,		atol=1e-3		)		)
		def 						__lowercase      (						self							:       Any		)      ->			str:







									'''simple docstring'''





									_lowercase							:		Tuple				=   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
									_lowercase							:		Dict				=   np.random.rand(100		).astype(np.floataa		)
									_lowercase							:		Union[str, Any]				=   np_audio_inputs.tolist()

									for inputs in [py_audio_inputs, np_audio_inputs]:
																_lowercase							:		List[str]				=   feature_extractor.pad([{'''input_values''': inputs}]      ,		return_tensors='''np'''		)
																self.assertTrue(np_processed.input_values.dtype == np.floataa		)
																_lowercase							:		Optional[int]				=   feature_extractor.pad([{'''input_values''': inputs}]      ,		return_tensors='''pt'''		)
																self.assertTrue(pt_processed.input_values.dtype == torch.floataa		)
		def 						__lowercase      (						self							:       int      ,		UpperCamelCase_							:       Any		)      ->			Union[str, Any]:







									'''simple docstring'''





									from datasets import load_dataset

									_lowercase							:		Tuple				=   load_dataset('''hf-internal-testing/librispeech_asr_dummy'''      ,		'''clean'''      ,		split='''validation'''		)
									# automatic decoding with librispeech
									_lowercase							:		List[str]				=   ds.sort('''id'''		).select(range(UpperCamelCase_		)		)[:num_samples]['''audio''']

									return [x["array"] for x in audio_samples]
		def 						__lowercase      (						self							:       Any		)      ->			int:







									'''simple docstring'''





									_lowercase							:		Optional[Any]				=   torch.tensor(
									    [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
									     3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
									     2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
									     4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
									     7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
									     4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03]		)
									# fmt: on
									_lowercase							:		Optional[int]				=   self._load_datasamples(1		)
									_lowercase							:		Dict				=   EncodecFeatureExtractor()
									_lowercase							:		Tuple				=   feature_extractor(UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(input_values.shape      ,		(1, 1, 93_680)		)
									self.assertTrue(torch.allclose(input_values[0, 0, :30]      ,		UpperCamelCase_      ,		atol=1e-6		)		)
		def 						__lowercase      (						self							:       int		)      ->			List[str]:







									'''simple docstring'''





									_lowercase							:		Any				=   torch.tensor(
									    [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
									     3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
									     2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
									     4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
									     7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
									     4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03]		)
									# fmt: on
									_lowercase							:		List[str]				=   self._load_datasamples(1		)
									_lowercase							:		List[str]				=   [np.tile(input_audio[0][None]      ,		reps=(2, 1)		)]
									input_audio[0][1] *= 0.5
									_lowercase							:		int				=   EncodecFeatureExtractor(feature_size=2		)
									_lowercase							:		List[str]				=   feature_extractor(UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(input_values.shape      ,		(1, 2, 93_680)		)
									self.assertTrue(torch.allclose(input_values[0, 0, :30]      ,		UpperCamelCase_      ,		atol=1e-6		)		)
									self.assertTrue(torch.allclose(input_values[0, 1, :30]      ,		EXPECTED_INPUT_VALUES * 0.5      ,		atol=1e-6		)		)





		def 						__lowercase      (						self							:       int		)      ->			List[Any]:







									'''simple docstring'''





									_lowercase							:		str				=   self._load_datasamples(2		)
									# would be easier if the stride was like
									_lowercase							:		Tuple				=   EncodecFeatureExtractor(feature_size=1      ,		chunk_length_s=1      ,		overlap=0.01		)

									# pad and trunc raise an error ?
									with self.assertRaisesRegex(
									    UpperCamelCase_      ,		'''^Both padding and truncation were set. Make sure you only set one.$'''      ,		):
																_lowercase							:		List[Any]				=   feature_extractor(
																    UpperCamelCase_      ,		padding='''max_length'''      ,		truncation=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values

									# truncate to chunk
									_lowercase							:		Union[str, Any]				=   feature_extractor(UpperCamelCase_      ,		truncation=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(2, 1, 71_520)		)  # 2 chunks

									# force truncate to max_length
									_lowercase							:		Tuple				=   feature_extractor(
									    UpperCamelCase_      ,		truncation=UpperCamelCase_      ,		max_length=48_000      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(2, 1, 48_000)		)

									# pad to chunk
									_lowercase							:		int				=   feature_extractor(UpperCamelCase_      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(padded_outputs.shape      ,		(2, 1, 95_280)		)

									# pad to chunk
									_lowercase							:		Dict				=   feature_extractor(UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(2, 1, 95_280)		)

									# force pad to max length
									_lowercase							:		int				=   feature_extractor(
									    UpperCamelCase_      ,		padding='''max_length'''      ,		max_length=100_000      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(2, 1, 100_000)		)

									# force no pad
									with self.assertRaisesRegex(
									    UpperCamelCase_      ,		'''^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'''      ,		):
																_lowercase							:		Any				=   feature_extractor(UpperCamelCase_      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values

									_lowercase							:		Dict				=   feature_extractor(input_audio[0]      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(1, 1, 93_680)		)

									# no pad if no chunk_length_s
									_lowercase							:		Optional[int]				=   None
									with self.assertRaisesRegex(
									    UpperCamelCase_      ,		'''^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'''      ,		):
																_lowercase							:		Optional[Any]				=   feature_extractor(UpperCamelCase_      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values

									_lowercase							:		Union[str, Any]				=   feature_extractor(input_audio[0]      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(1, 1, 93_680)		)

									# no pad if no overlap
									_lowercase							:		int				=   2
									_lowercase							:		Optional[Any]				=   None
									with self.assertRaisesRegex(
									    UpperCamelCase_      ,		'''^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'''      ,		):
																_lowercase							:		Optional[Any]				=   feature_extractor(UpperCamelCase_      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values

									_lowercase							:		Any				=   feature_extractor(input_audio[0]      ,		padding=UpperCamelCase_      ,		return_tensors='''pt'''		).input_values
									self.assertEquals(truncated_outputs.shape      ,		(1, 1, 93_680)		)








'''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 				_SCREAMING_SNAKE_CASE(					snake_case_    :     nn.Module  )		->Any:






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





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     nn.Module  )		->List[Any]:






							'''simple docstring'''
							_lowercase							:		int				=   {}
							_lowercase							:		str				=   (
							    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_  ):
																					_lowercase							:		Optional[int]				=   lora_attn_processor_class(
																					    hidden_size=module.out_proj.out_features ,       cross_attention_dim=snake_case_  )
							return text_lora_attn_procs





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     nn.Module  )		->Union[str, Any]:






							'''simple docstring'''
							_lowercase							:		List[str]				=   create_text_encoder_lora_attn_procs(snake_case_  )
							_lowercase							:		List[Any]				=   AttnProcsLayers(snake_case_  )
							return text_encoder_lora_layers





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Dict ,       snake_case_    :     str=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'''  ):
																												_lowercase							:		Tuple				=   (
																												    torch.randn_like(layer_module.up.weight  )
																												    if randn_weight
																												    else torch.zeros_like(layer_module.up.weight  )
																												)
																												_lowercase							:		Any				=   torch.nn.Parameter(snake_case_  )




class 	_lowerCAmelCase     (    unittest.TestCase       ):






		'''simple docstring'''
		def 						__lowercase      (						self							:       Dict		)      ->			Tuple:







									'''simple docstring'''





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

									_lowercase			, _lowercase							:		Optional[int]				=   create_unet_lora_layers(UpperCamelCase_		)
									_lowercase							:		Optional[int]				=   create_text_encoder_lora_layers(UpperCamelCase_		)

									_lowercase							:		Dict				=   {
									    '''unet''': unet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									_lowercase							:		List[str]				=   {
									    '''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 						__lowercase      (						self							:       Optional[Any]		)      ->			Optional[Any]:







									'''simple docstring'''





									_lowercase							:		Optional[Any]				=   1
									_lowercase							:		List[Any]				=   10
									_lowercase							:		Union[str, Any]				=   4
									_lowercase							:		Union[str, Any]				=   (32, 32)

									_lowercase							:		Optional[Any]				=   torch.manual_seed(0		)
									_lowercase							:		Tuple				=   floats_tensor((batch_size, num_channels) + sizes		)
									_lowercase							:		str				=   torch.randint(1      ,		UpperCamelCase_      ,		size=(batch_size, sequence_length)      ,		generator=UpperCamelCase_		)

									_lowercase							:		Optional[Any]				=   {
									    '''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 						__lowercase      (						self							:       Union[str, Any]		)      ->			Any:







									'''simple docstring'''





									_lowercase							:		Optional[Any]				=   77

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

									_lowercase							:		List[str]				=   {}
									_lowercase							:		Optional[Any]				=   inputs
									return prepared_inputs
		def 						__lowercase      (						self							:       List[str]      ,		UpperCamelCase_							:       str		)      ->			List[str]:







									'''simple docstring'''





									_lowercase			, _lowercase							:		Tuple				=   self.get_dummy_components()
									LoraLoaderMixin.save_lora_weights(
									    save_directory=UpperCamelCase_      ,		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(UpperCamelCase_      ,		'''pytorch_lora_weights.bin'''		)		)		)
		def 						__lowercase      (						self							:       List[str]		)      ->			Union[str, Any]:







									'''simple docstring'''





									_lowercase			, _lowercase							:		Any				=   self.get_dummy_components()
									_lowercase							:		Tuple				=   StableDiffusionPipeline(**UpperCamelCase_		)
									_lowercase							:		Optional[Any]				=   sd_pipe.to(UpperCamelCase_		)
									sd_pipe.set_progress_bar_config(disable=UpperCamelCase_		)

									_lowercase			, _lowercase			, _lowercase							:		Dict				=   self.get_dummy_inputs()

									_lowercase							:		Optional[int]				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		Optional[Any]				=   original_images[0, -3:, -3:, -1]

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

									_lowercase							:		Dict				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		Any				=   lora_images[0, -3:, -3:, -1]

									# Outputs shouldn't match.
									self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase_		)      ,		torch.from_numpy(UpperCamelCase_		)		)		)
		def 						__lowercase      (						self							:       List[str]		)      ->			Optional[int]:







									'''simple docstring'''





									_lowercase			, _lowercase							:		Tuple				=   self.get_dummy_components()
									_lowercase							:		int				=   StableDiffusionPipeline(**UpperCamelCase_		)
									_lowercase							:		Dict				=   sd_pipe.to(UpperCamelCase_		)
									sd_pipe.set_progress_bar_config(disable=UpperCamelCase_		)

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

									_lowercase							:		Optional[Any]				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		str				=   original_images[0, -3:, -3:, -1]

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

									_lowercase							:		int				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		int				=   lora_images[0, -3:, -3:, -1]

									# Outputs shouldn't match.
									self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase_		)      ,		torch.from_numpy(UpperCamelCase_		)		)		)
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			Tuple:







									'''simple docstring'''





									_lowercase			, _lowercase							:		str				=   self.get_dummy_components()
									_lowercase							:		Optional[Any]				=   lora_components['''unet_lora_attn_procs''']
									_lowercase							:		Optional[int]				=   StableDiffusionPipeline(**UpperCamelCase_		)
									_lowercase							:		List[str]				=   sd_pipe.to(UpperCamelCase_		)
									sd_pipe.set_progress_bar_config(disable=UpperCamelCase_		)

									_lowercase			, _lowercase			, _lowercase							:		Any				=   self.get_dummy_inputs()

									_lowercase							:		Any				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		Union[str, Any]				=   original_images[0, -3:, -3:, -1]

									with tempfile.TemporaryDirectory() as tmpdirname:
																_lowercase							:		Union[str, Any]				=   sd_pipe.unet
																unet.set_attn_processor(UpperCamelCase_		)
																unet.save_attn_procs(UpperCamelCase_		)
																self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase_      ,		'''pytorch_lora_weights.bin'''		)		)		)
																sd_pipe.load_lora_weights(UpperCamelCase_		)

									_lowercase							:		List[str]				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		Tuple				=   lora_images[0, -3:, -3:, -1]

									# Outputs shouldn't match.
									self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase_		)      ,		torch.from_numpy(UpperCamelCase_		)		)		)
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			Tuple:







									'''simple docstring'''





									_lowercase			, _lowercase							:		Union[str, Any]				=   self.get_dummy_components()
									_lowercase							:		Any				=   StableDiffusionPipeline(**UpperCamelCase_		)

									_lowercase							:		int				=   self.get_dummy_tokens()

									# inference without lora
									_lowercase							:		Dict				=   pipe.text_encoder(**UpperCamelCase_		)[0]
									assert outputs_without_lora.shape == (1, 77, 32)

									# create lora_attn_procs with zeroed out up.weights
									_lowercase							:		Any				=   create_text_encoder_lora_attn_procs(pipe.text_encoder		)
									set_lora_up_weights(UpperCamelCase_      ,		randn_weight=UpperCamelCase_		)

									# monkey patch
									pipe._modify_text_encoder(UpperCamelCase_		)

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

									# inference with lora
									_lowercase							:		Dict				=   pipe.text_encoder(**UpperCamelCase_		)[0]
									assert outputs_with_lora.shape == (1, 77, 32)

									assert torch.allclose(
									    UpperCamelCase_      ,		UpperCamelCase_		), "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
									_lowercase							:		str				=   create_text_encoder_lora_attn_procs(pipe.text_encoder		)
									set_lora_up_weights(UpperCamelCase_      ,		randn_weight=UpperCamelCase_		)

									# monkey patch
									pipe._modify_text_encoder(UpperCamelCase_		)

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

									# inference with lora
									_lowercase							:		List[str]				=   pipe.text_encoder(**UpperCamelCase_		)[0]
									assert outputs_with_lora.shape == (1, 77, 32)

									assert not torch.allclose(
									    UpperCamelCase_      ,		UpperCamelCase_		), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
		def 						__lowercase      (						self							:       List[Any]		)      ->			Union[str, Any]:







									'''simple docstring'''





									_lowercase			, _lowercase							:		Optional[Any]				=   self.get_dummy_components()
									_lowercase							:		int				=   StableDiffusionPipeline(**UpperCamelCase_		)

									_lowercase							:		Tuple				=   self.get_dummy_tokens()

									# inference without lora
									_lowercase							:		Any				=   pipe.text_encoder(**UpperCamelCase_		)[0]
									assert outputs_without_lora.shape == (1, 77, 32)

									# create lora_attn_procs with randn up.weights
									_lowercase							:		Tuple				=   create_text_encoder_lora_attn_procs(pipe.text_encoder		)
									set_lora_up_weights(UpperCamelCase_      ,		randn_weight=UpperCamelCase_		)

									# monkey patch
									pipe._modify_text_encoder(UpperCamelCase_		)

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

									# inference with lora
									_lowercase							:		Tuple				=   pipe.text_encoder(**UpperCamelCase_		)[0]
									assert outputs_with_lora.shape == (1, 77, 32)

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

									# remove monkey patch
									pipe._remove_text_encoder_monkey_patch()

									# inference with removed lora
									_lowercase							:		Dict				=   pipe.text_encoder(**UpperCamelCase_		)[0]
									assert outputs_without_lora_removed.shape == (1, 77, 32)

									assert torch.allclose(
									    UpperCamelCase_      ,		UpperCamelCase_		), "remove lora monkey patch should restore the original outputs"
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			Optional[Any]:







									'''simple docstring'''





									_lowercase			, _lowercase							:		str				=   self.get_dummy_components()
									_lowercase							:		Optional[Any]				=   StableDiffusionPipeline(**UpperCamelCase_		)
									_lowercase							:		str				=   sd_pipe.to(UpperCamelCase_		)
									sd_pipe.set_progress_bar_config(disable=UpperCamelCase_		)

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

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

									_lowercase							:		Dict				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		List[Any]				=   lora_images[0, -3:, -3:, -1]

									_lowercase							:		List[str]				=   sd_pipe(**UpperCamelCase_      ,		cross_attention_kwargs={'''scale''': 0.5}		).images
									_lowercase							:		Tuple				=   lora_images_with_scale[0, -3:, -3:, -1]

									# Outputs shouldn't match.
									self.assertFalse(
									    torch.allclose(torch.from_numpy(UpperCamelCase_		)      ,		torch.from_numpy(UpperCamelCase_		)		)		)
		def 						__lowercase      (						self							:       str		)      ->			Optional[int]:







									'''simple docstring'''





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

																_lowercase			, _lowercase							:		Union[str, Any]				=   self.get_dummy_components()
																_lowercase							:		Tuple				=   StableDiffusionPipeline(**UpperCamelCase_		)
																_lowercase							:		List[Any]				=   sd_pipe.to(UpperCamelCase_		)
																sd_pipe.set_progress_bar_config(disable=UpperCamelCase_		)

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

            # load LoRA weight file
																sd_pipe.load_lora_weights(UpperCamelCase_		)

																# check if lora attention processors are used
																for _, module in sd_pipe.unet.named_modules():
																							if isinstance(UpperCamelCase_      ,		UpperCamelCase_		):
																														_lowercase							:		Optional[Any]				=   (
																														    LoRAAttnProcessor2_0 if hasattr(UpperCamelCase_      ,		'''scaled_dot_product_attention'''		) else LoRAAttnProcessor
																														)
																														self.assertIsInstance(module.processor      ,		UpperCamelCase_		)
		@unittest.skipIf(torch_device != '''cuda'''      ,		'''This test is supposed to run on GPU'''		)
		def 						__lowercase      (						self							:       str		)      ->			Tuple:







									'''simple docstring'''





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

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

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

            # load LoRA weight file
																sd_pipe.load_lora_weights(UpperCamelCase_		)

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





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







									'''simple docstring'''





									_lowercase			, _lowercase							:		Dict				=   self.get_dummy_components()
									_lowercase							:		Dict				=   StableDiffusionPipeline(**UpperCamelCase_		)
									_lowercase							:		Union[str, Any]				=   sd_pipe.to(UpperCamelCase_		)
									sd_pipe.set_progress_bar_config(disable=UpperCamelCase_		)

									_lowercase			, _lowercase			, _lowercase							:		Dict				=   self.get_dummy_inputs()

									# enable XFormers
									sd_pipe.enable_xformers_memory_efficient_attention()

									_lowercase							:		Union[str, Any]				=   sd_pipe(**UpperCamelCase_		).images
									_lowercase							:		Dict				=   original_images[0, -3:, -3:, -1]

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

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

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



