






import tempfile
import unittest

from transformers import DPRConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
      import torch

      from transformers import DPRContextEncoder, DPRQuestionEncoder, DPRReader, DPRReaderTokenizer
      from transformers.models.dpr.modeling_dpr import (
          DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
          DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
          DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )
class 	a_:



     """simple docstring"""



     def __init__(		self					:	Tuple  ,  lowerCAmelCase__					:	Union[str, Any]  ,  lowerCAmelCase__					:	int=1_3  ,  lowerCAmelCase__					:	Optional[int]=7  ,  lowerCAmelCase__					:	Union[str, Any]=False  ,  lowerCAmelCase__					:	int=True  ,  lowerCAmelCase__					:	Dict=True  ,  lowerCAmelCase__					:	Dict=True  ,  lowerCAmelCase__					:	Any=9_9  ,  lowerCAmelCase__					:	Optional[Any]=3_2  ,  lowerCAmelCase__					:	str=5  ,  lowerCAmelCase__					:	Tuple=4  ,  lowerCAmelCase__					:	List[str]=3_7  ,  lowerCAmelCase__					:	Optional[int]="gelu"  ,  lowerCAmelCase__					:	Optional[Any]=0.1  ,  lowerCAmelCase__					:	List[str]=0.1  ,  lowerCAmelCase__					:	List[str]=5_1_2  ,  lowerCAmelCase__					:	Optional[int]=1_6  ,  lowerCAmelCase__					:	Any=2  ,  lowerCAmelCase__					:	List[str]=0.02  ,  lowerCAmelCase__					:	int=3  ,  lowerCAmelCase__					:	str=4  ,  lowerCAmelCase__					:	Any=None  ,  lowerCAmelCase__					:	Dict=0  ,  )							->	List[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		parent
      SCREAMING_SNAKE_CASE				    =		batch_size
      SCREAMING_SNAKE_CASE				    =		seq_length
      SCREAMING_SNAKE_CASE				    =		is_training
      SCREAMING_SNAKE_CASE				    =		use_input_mask
      SCREAMING_SNAKE_CASE				    =		use_token_type_ids
      SCREAMING_SNAKE_CASE				    =		use_labels
      SCREAMING_SNAKE_CASE				    =		vocab_size
      SCREAMING_SNAKE_CASE				    =		hidden_size
      SCREAMING_SNAKE_CASE				    =		num_hidden_layers
      SCREAMING_SNAKE_CASE				    =		num_attention_heads
      SCREAMING_SNAKE_CASE				    =		intermediate_size
      SCREAMING_SNAKE_CASE				    =		hidden_act
      SCREAMING_SNAKE_CASE				    =		hidden_dropout_prob
      SCREAMING_SNAKE_CASE				    =		attention_probs_dropout_prob
      SCREAMING_SNAKE_CASE				    =		max_position_embeddings
      SCREAMING_SNAKE_CASE				    =		type_vocab_size
      SCREAMING_SNAKE_CASE				    =		type_sequence_label_size
      SCREAMING_SNAKE_CASE				    =		initializer_range
      SCREAMING_SNAKE_CASE				    =		num_labels
      SCREAMING_SNAKE_CASE				    =		num_choices
      SCREAMING_SNAKE_CASE				    =		scope
      SCREAMING_SNAKE_CASE				    =		projection_dim





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		ids_tensor([self.batch_size, self.seq_length]  ,  self.vocab_size)

      SCREAMING_SNAKE_CASE				    =		None
      if self.use_input_mask:
       SCREAMING_SNAKE_CASE				    =		random_attention_mask([self.batch_size, self.seq_length])

      SCREAMING_SNAKE_CASE				    =		None
      if self.use_token_type_ids:
       SCREAMING_SNAKE_CASE				    =		ids_tensor([self.batch_size, self.seq_length]  ,  self.type_vocab_size)

      SCREAMING_SNAKE_CASE				    =		None
      SCREAMING_SNAKE_CASE				    =		None
      SCREAMING_SNAKE_CASE				    =		None
      if self.use_labels:
       SCREAMING_SNAKE_CASE				    =		ids_tensor([self.batch_size]  ,  self.type_sequence_label_size)
       SCREAMING_SNAKE_CASE				    =		ids_tensor([self.batch_size, self.seq_length]  ,  self.num_labels)
       SCREAMING_SNAKE_CASE				    =		ids_tensor([self.batch_size]  ,  self.num_choices)

      SCREAMING_SNAKE_CASE				    =		self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





     def     __UpperCamelCase						(		self					:	List[str])							->	Optional[Any]:

      """simple docstring"""
      return DPRConfig(
          projection_dim=self.projection_dim  ,  vocab_size=self.vocab_size  ,  hidden_size=self.hidden_size  ,  num_hidden_layers=self.num_hidden_layers  ,  num_attention_heads=self.num_attention_heads  ,  intermediate_size=self.intermediate_size  ,  hidden_act=self.hidden_act  ,  hidden_dropout_prob=self.hidden_dropout_prob  ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,  max_position_embeddings=self.max_position_embeddings  ,  type_vocab_size=self.type_vocab_size  ,  initializer_range=self.initializer_range  ,  )





     def     __UpperCamelCase						(		self					:	Tuple  ,  lowerCAmelCase__					:	List[Any]  ,  lowerCAmelCase__					:	List[str]  ,  lowerCAmelCase__					:	List[str]  ,  lowerCAmelCase__					:	int  ,  lowerCAmelCase__					:	str  ,  lowerCAmelCase__					:	Dict  ,  lowerCAmelCase__					:	str)							->	Any:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		DPRContextEncoder(config=lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__  ,  attention_mask=lowerCAmelCase__  ,  token_type_ids=lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__  ,  token_type_ids=lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__)
      self.parent.assertEqual(result.pooler_output.shape  ,  (self.batch_size, self.projection_dim or self.hidden_size))





     def     __UpperCamelCase						(		self					:	Optional[Any]  ,  lowerCAmelCase__					:	Optional[Any]  ,  lowerCAmelCase__					:	Optional[int]  ,  lowerCAmelCase__					:	str  ,  lowerCAmelCase__					:	Any  ,  lowerCAmelCase__					:	Dict  ,  lowerCAmelCase__					:	Tuple  ,  lowerCAmelCase__					:	List[str])							->	List[str]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		DPRQuestionEncoder(config=lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__  ,  attention_mask=lowerCAmelCase__  ,  token_type_ids=lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__  ,  token_type_ids=lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__)
      self.parent.assertEqual(result.pooler_output.shape  ,  (self.batch_size, self.projection_dim or self.hidden_size))





     def     __UpperCamelCase						(		self					:	str  ,  lowerCAmelCase__					:	Any  ,  lowerCAmelCase__					:	Optional[int]  ,  lowerCAmelCase__					:	Optional[int]  ,  lowerCAmelCase__					:	Dict  ,  lowerCAmelCase__					:	List[str]  ,  lowerCAmelCase__					:	int  ,  lowerCAmelCase__					:	Tuple)							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		DPRReader(config=lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      SCREAMING_SNAKE_CASE				    =		model(
          lowerCAmelCase__  ,  attention_mask=lowerCAmelCase__  ,  )

      self.parent.assertEqual(result.start_logits.shape  ,  (self.batch_size, self.seq_length))
      self.parent.assertEqual(result.end_logits.shape  ,  (self.batch_size, self.seq_length))
      self.parent.assertEqual(result.relevance_logits.shape  ,  (self.batch_size,))





     def     __UpperCamelCase						(		self					:	Any)							->	Dict:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.prepare_config_and_inputs()
      (
          (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   
      )				    =		config_and_inputs
      SCREAMING_SNAKE_CASE				    =		{'input_ids': input_ids}
      return config, inputs_dict

@require_torch
class 	a_(		lowercase__			,							lowercase__			,							unittest.TestCase	):



     """simple docstring"""



     __snake_case		:				Union[str, Any]  					=(
         (
             DPRContextEncoder,
             DPRQuestionEncoder,
             DPRReader,
         )
         if is_torch_available()
         else ()
     )
     __snake_case		:				Union[str, Any]  					={'''feature-extraction''': DPRQuestionEncoder} if is_torch_available() else {}

     __snake_case		:				List[str]  					=False
     __snake_case		:				Tuple  					=False  # why?
     __snake_case		:				Tuple  					=False
     __snake_case		:				Optional[Any]  					=False





     def     __UpperCamelCase						(		self					:	Optional[int])							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		DPRModelTester(self)
      SCREAMING_SNAKE_CASE				    =		ConfigTester(self  ,  config_class=lowerCAmelCase__  ,  hidden_size=3_7)





     def     __UpperCamelCase						(		self					:	Tuple)							->	List[Any]:

      """simple docstring"""
      self.config_tester.run_common_tests()





     def     __UpperCamelCase						(		self					:	Union[str, Any])							->	Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_context_encoder(*lowerCAmelCase__)





     def     __UpperCamelCase						(		self					:	List[str])							->	int:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_question_encoder(*lowerCAmelCase__)





     def     __UpperCamelCase						(		self					:	str)							->	Optional[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_reader(*lowerCAmelCase__)





     def     __UpperCamelCase						(		self					:	Dict)							->	List[str]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()[0]

      SCREAMING_SNAKE_CASE				    =		DPRQuestionEncoder(config=lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()

      with tempfile.TemporaryDirectory() as tmp_dirname:
       model.save_pretrained(lowerCAmelCase__)
       SCREAMING_SNAKE_CASE				    =		DPRQuestionEncoder.from_pretrained(lowerCAmelCase__  ,  projection_dim=5_1_2)

      self.assertIsNotNone(lowerCAmelCase__)





     @slow
     def     __UpperCamelCase						(		self					:	int)							->	Dict:

      """simple docstring"""
      for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       SCREAMING_SNAKE_CASE				    =		DPRContextEncoder.from_pretrained(lowerCAmelCase__)
       self.assertIsNotNone(lowerCAmelCase__)

      for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       SCREAMING_SNAKE_CASE				    =		DPRContextEncoder.from_pretrained(lowerCAmelCase__)
       self.assertIsNotNone(lowerCAmelCase__)

      for model_name in DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       SCREAMING_SNAKE_CASE				    =		DPRQuestionEncoder.from_pretrained(lowerCAmelCase__)
       self.assertIsNotNone(lowerCAmelCase__)

      for model_name in DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       SCREAMING_SNAKE_CASE				    =		DPRReader.from_pretrained(lowerCAmelCase__)
       self.assertIsNotNone(lowerCAmelCase__)

@require_torch
class 	a_(		unittest.TestCase	):



     """simple docstring"""



     @slow
     def     __UpperCamelCase						(		self					:	List[Any])							->	Dict:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		DPRQuestionEncoder.from_pretrained('facebook/dpr-question_encoder-single-nq-base'  ,  return_dict=lowerCAmelCase__)
      model.to(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		torch.tensor(
          [[1_0_1, 7_5_9_2, 1_0_1_0, 2_0_0_3, 2_0_2_6, 3_8_9_9, 1_0_1_4_0, 1_0_2_9, 1_0_2]]  ,  dtype=torch.long  ,  device=lowerCAmelCase__)  # [CLS] hello, is my dog cute? [SEP]
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__)[0]  # embedding shape = (1, 768)
      # compare the actual values for a slice.
      SCREAMING_SNAKE_CASE				    =		torch.tensor(
          [
              [
                  0.03_23_62_53,
                  0.12_75_33_35,
                  0.16_81_85_09,
                  0.00_27_97_86,
                  0.3_89_69_33,
                  0.24_26_49_45,
                  0.2_17_89_71,
                  -0.02_33_52_27,
                  -0.08_48_19_59,
                  -0.14_32_41_17,
              ]
          ]  ,  dtype=torch.float  ,  device=lowerCAmelCase__  ,  )
      self.assertTrue(torch.allclose(output[:, :1_0]  ,  lowerCAmelCase__  ,  atol=1e-4))





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		DPRReaderTokenizer.from_pretrained('facebook/dpr-reader-single-nq-base')
      SCREAMING_SNAKE_CASE				    =		DPRReader.from_pretrained('facebook/dpr-reader-single-nq-base')
      model.to(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		tokenizer(
          questions='What is love ?'  ,  titles='Haddaway'  ,  texts='What Is Love is a song recorded by the artist Haddaway'  ,  padding=lowerCAmelCase__  ,  return_tensors='pt'  ,  )
      encoded_inputs.to(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		model(**lowerCAmelCase__)

      # compare the actual values for a slice.
      SCREAMING_SNAKE_CASE				    =		torch.tensor(
          [[-10.30_05, -10.77_65, -11.48_72, -11.68_41, -11.93_12, -10.30_02, -9.85_44, -11.73_78, -12.08_21, -10.29_75]]  ,  dtype=torch.float  ,  device=lowerCAmelCase__  ,  )

      SCREAMING_SNAKE_CASE				    =		torch.tensor(
          [[-11.06_84, -11.70_41, -11.53_97, -10.34_65, -10.87_91, -6.84_43, -11.99_59, -11.03_64, -10.00_96, -6.84_05]]  ,  dtype=torch.float  ,  device=lowerCAmelCase__  ,  )
      self.assertTrue(torch.allclose(outputs.start_logits[:, :1_0]  ,  lowerCAmelCase__  ,  atol=1e-4))
      self.assertTrue(torch.allclose(outputs.end_logits[:, :1_0]  ,  lowerCAmelCase__  ,  atol=1e-4))










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





