






'''simple docstring'''


from __future__ import annotations

import unittest
import warnings

from transformers import AutoTokenizer, MarianConfig, MarianTokenizer, TranslationPipeline, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import TFAutoModelForSeqaSeqLM, TFMarianModel, TFMarianMTModel




@require_tf
class 							lowerCAmelCase					:







   """simple docstring"""







   _A						=   MarianConfig
   _A						=   {}
   _A						=   'gelu'



   def __init__( self   ,   _A   ,   _A=13   ,   _A=7   ,   _A=True   ,   _A=False   ,   _A=99   ,   _A=32   ,   _A=2   ,   _A=4   ,   _A=37   ,   _A=0.1   ,   _A=0.1   ,   _A=20   ,   _A=2   ,   _A=1   ,   _A=0   ,   )    ->   List[str]:
    __a    :	Dict									=						parent
    __a    :	Optional[Any]									=						batch_size
    __a    :	Dict									=						seq_length
    __a    :	List[str]									=						is_training
    __a    :	str									=						use_labels
    __a    :	Optional[int]									=						vocab_size
    __a    :	List[str]									=						hidden_size
    __a    :	int									=						num_hidden_layers
    __a    :	Optional[Any]									=						num_attention_heads
    __a    :	Any									=						intermediate_size

    __a    :	Optional[int]									=						hidden_dropout_prob
    __a    :	int									=						attention_probs_dropout_prob
    __a    :	Optional[int]									=						max_position_embeddings
    __a    :	Optional[Any]									=						eos_token_id
    __a    :	Union[str, Any]									=						pad_token_id
    __a    :	int									=						bos_token_id



   def    __magic_name__    ( self			)    ->   Optional[Any]:
    __a    :	Tuple									=						ids_tensor([self.batch_size, self.seq_length - 1]   ,   self.vocab_size			)
    __a    :	Union[str, Any]									=						tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size			)   ,   1			)
    __a    :	str									=						tf.concat([input_ids, eos_tensor]   ,   axis=1			)

    __a    :	Dict									=						ids_tensor([self.batch_size, self.seq_length]   ,   self.vocab_size			)

    __a    :	Union[str, Any]									=						self.config_cls(
        vocab_size=self.vocab_size   ,   d_model=self.hidden_size   ,   encoder_layers=self.num_hidden_layers   ,   decoder_layers=self.num_hidden_layers   ,   encoder_attention_heads=self.num_attention_heads   ,   decoder_attention_heads=self.num_attention_heads   ,   encoder_ffn_dim=self.intermediate_size   ,   decoder_ffn_dim=self.intermediate_size   ,   dropout=self.hidden_dropout_prob   ,   attention_dropout=self.attention_probs_dropout_prob   ,   max_position_embeddings=self.max_position_embeddings   ,   eos_token_ids=[2]   ,   bos_token_id=self.bos_token_id   ,   pad_token_id=self.pad_token_id   ,   decoder_start_token_id=self.pad_token_id   ,   **self.config_updates   ,   )
    __a    :	List[str]									=						prepare_marian_inputs_dict(_A   ,   _A   ,   _A			)
    return config, inputs_dict



   def    __magic_name__    ( self   ,   _A   ,   _A			)    ->   List[str]:
    __a    :	int									=						TFMarianModel(config=_A			).get_decoder()
    __a    :	Optional[int]									=						inputs_dict['input_ids']

    __a    :	List[str]									=						input_ids[:1, :]
    __a    :	int									=						inputs_dict['attention_mask'][:1, :]
    __a    :	List[Any]									=						inputs_dict['head_mask']
    __a    :	Any									=						1

    # first forward pass
    __a    :	List[str]									=						model(_A   ,   attention_mask=_A   ,   head_mask=_A   ,   use_cache=_A			)

    __a			,    __a    :	Union[str, Any]									=						outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    __a    :	Tuple									=						ids_tensor((self.batch_size, 3)   ,   config.vocab_size			)
    __a    :	Any									=						tf.cast(ids_tensor((self.batch_size, 3)   ,   2			)   ,   tf.inta			)

    # append to next input_ids and
    __a    :	int									=						tf.concat([input_ids, next_tokens]   ,   axis=-1			)
    __a    :	List[str]									=						tf.concat([attention_mask, next_attn_mask]   ,   axis=-1			)

    __a    :	Union[str, Any]									=						model(_A   ,   attention_mask=_A			)[0]
    __a    :	Tuple									=						model(_A   ,   attention_mask=_A   ,   past_key_values=_A			)[0]

    self.parent.assertEqual(next_tokens.shape[1]   ,   output_from_past.shape[1]			)

    # select random slice
    __a    :	int									=						int(ids_tensor((1,)   ,   output_from_past.shape[-1]			)			)
    __a    :	List[Any]									=						output_from_no_past[:, -3:, random_slice_idx]
    __a    :	Tuple									=						output_from_past[:, :, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(_A   ,   _A   ,   rtol=1E-3			)






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__=None       ,		SCREAMING_SNAKE_CASE__=None       ,		SCREAMING_SNAKE_CASE__=None       ,		SCREAMING_SNAKE_CASE__=None       ,		SCREAMING_SNAKE_CASE__=None       ,		):
 if attention_mask is None:
  __a    :	Dict									=						tf.cast(tf.math.not_equal(SCREAMING_SNAKE_CASE__       ,		config.pad_token_id		)       ,		tf.inta		)
 if decoder_attention_mask is None:
  __a    :	List[Any]									=						tf.concat(
      [
          tf.ones(decoder_input_ids[:, :1].shape       ,		dtype=tf.inta		),
          tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]       ,		config.pad_token_id		)       ,		tf.inta		),
      ]       ,		axis=-1       ,		)
 if head_mask is None:
  __a    :	int									=						tf.ones((config.encoder_layers, config.encoder_attention_heads)		)
 if decoder_head_mask is None:
  __a    :	Optional[Any]									=						tf.ones((config.decoder_layers, config.decoder_attention_heads)		)
 if cross_attn_head_mask is None:
  __a    :	Union[str, Any]									=						tf.ones((config.decoder_layers, config.decoder_attention_heads)		)
 return {
     "input_ids": input_ids,
     "decoder_input_ids": decoder_input_ids,
     "attention_mask": attention_mask,
     "decoder_attention_mask": decoder_attention_mask,
     "head_mask": head_mask,
     "decoder_head_mask": decoder_head_mask,
     "cross_attn_head_mask": cross_attn_head_mask,
 }




@require_tf
class 							lowerCAmelCase					(							lowerCamelCase__							,      lowerCamelCase__							,      unittest.TestCase   ):







   """simple docstring"""







   _A						=   (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
   _A						=   (TFMarianMTModel,) if is_tf_available() else ()
   _A						=   (
       {
           'conversational': TFMarianMTModel,
           'feature-extraction': TFMarianModel,
           'summarization': TFMarianMTModel,
           'text2text-generation': TFMarianMTModel,
           'translation': TFMarianMTModel,
       }
       if is_tf_available()
       else {}
   )
   _A						=   True
   _A						=   False
   _A						=   False



   def    __magic_name__    ( self			)    ->   Optional[int]:
    __a    :	Optional[Any]									=						TFMarianModelTester(self			)
    __a    :	Optional[int]									=						ConfigTester(self   ,   config_class=_A			)



   def    __magic_name__    ( self			)    ->   int:
    self.config_tester.run_common_tests()



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a    :	List[str]									=						self.model_tester.prepare_config_and_inputs_for_common()
    self.model_tester.check_decoder_model_past_large_inputs(*_A			)




@require_tf
class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   _A						=   10_00  # show more chars for failing integration tests



   @classmethod
   def    __magic_name__    ( cls			)    ->   None:
    __a    :	Union[str, Any]									=						f'''Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}'''
    return cls



   @cached_property
   def    __magic_name__    ( self			)    ->   MarianTokenizer:
    return AutoTokenizer.from_pretrained(self.model_name			)



   @property
   def    __magic_name__    ( self			)    ->   int:
    return self.tokenizer.eos_token_id



   @cached_property
   def    __magic_name__    ( self			)    ->   Dict:
    warnings.simplefilter('error'			)
    __a    :	TFMarianMTModel									=						TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name			)
    assert isinstance(_A   ,   _A			)
    __a    :	List[Any]									=						model.config
    self.assertListEqual(c.bad_words_ids   ,   [[c.pad_token_id]]			)
    self.assertEqual(c.max_length   ,   512			)
    self.assertEqual(c.decoder_start_token_id   ,   c.pad_token_id			)
    return model



   def    __magic_name__    ( self   ,   **_A			)    ->   Any:
    __a    :	List[str]									=						self.translate_src_text(**_A			)
    self.assertListEqual(self.expected_text   ,   _A			)



   def    __magic_name__    ( self   ,   **_A			)    ->   Optional[Any]:
    __a    :	List[Any]									=						self.tokenizer(self.src_text   ,   **_A   ,   padding=_A   ,   return_tensors='tf'			)
    __a    :	List[str]									=						self.model.generate(
        model_inputs.input_ids   ,   attention_mask=model_inputs.attention_mask   ,   num_beams=2   ,   max_length=128			)
    __a    :	List[str]									=						self.tokenizer.batch_decode(generated_ids.numpy()   ,   skip_special_tokens=_A			)
    return generated_words




@require_sentencepiece
@require_tokenizers
@require_tf
class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'mt'
   _A						=   'en'
   _A						=   ['Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.']
   _A						=   ['Touching gently, Jesus healed a man who was affected by the sad disease of leprosy.']



   @unittest.skip('Skipping until #12647 is resolved.'			)
   @slow
   def    __magic_name__    ( self			)    ->   Any:
    self._assert_generated_batch_equal_expected()




@require_sentencepiece
@require_tokenizers
@require_tf
class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'en'
   _A						=   'zh'
   _A						=   ['My name is Wolfgang and I live in Berlin']
   _A						=   ['我叫沃尔夫冈 我住在柏林']



   @unittest.skip('Skipping until #12647 is resolved.'			)
   @slow
   def    __magic_name__    ( self			)    ->   Any:
    self._assert_generated_batch_equal_expected()




@require_sentencepiece
@require_tokenizers
@require_tf
class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'en'
   _A						=   'ROMANCE'
   _A						=   [
       '>>fr<< Don\'t spend so much time watching TV.',
       '>>pt<< Your message has been sent.',
       '>>es<< He\'s two years older than me.',
   ]
   _A						=   [
       'Ne passez pas autant de temps à regarder la télé.',
       'A sua mensagem foi enviada.',
       'Es dos años más viejo que yo.',
   ]



   @unittest.skip('Skipping until #12647 is resolved.'			)
   @slow
   def    __magic_name__    ( self			)    ->   Optional[Any]:
    self._assert_generated_batch_equal_expected()



   @unittest.skip('Skipping until #12647 is resolved.'			)
   @slow
   def    __magic_name__    ( self			)    ->   List[str]:
    __a    :	Any									=						TranslationPipeline(self.model   ,   self.tokenizer   ,   framework='tf'			)
    __a    :	str									=						pipeline(self.src_text			)
    self.assertEqual(self.expected_text   ,   [x['translation_text'] for x in output]			)












'''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   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	List[str]									=						{}
 for name in unet.attn_processors.keys():
  __a    :	int									=						None if name.endswith('attn1.processor'		) else unet.config.cross_attention_dim
  if name.startswith('mid_block'		):
   __a    :	Tuple									=						unet.config.block_out_channels[-1]
  elif name.startswith('up_blocks'		):
   __a    :	int									=						int(name[len('up_blocks.'		)]		)
   __a    :	List[str]									=						list(reversed(unet.config.block_out_channels		)		)[block_id]
  elif name.startswith('down_blocks'		):
   __a    :	int									=						int(name[len('down_blocks.'		)]		)
   __a    :	Optional[Any]									=						unet.config.block_out_channels[block_id]
  __a    :	Optional[int]									=						(
      LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE__       ,		'scaled_dot_product_attention'		) else LoRAAttnProcessor
  )
  __a    :	Optional[Any]									=						lora_attn_processor_class(
      hidden_size=SCREAMING_SNAKE_CASE__       ,		cross_attention_dim=SCREAMING_SNAKE_CASE__		)
 __a    :	Tuple									=						AttnProcsLayers(SCREAMING_SNAKE_CASE__		)
 return lora_attn_procs, unet_lora_layers






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	Dict									=						{}
 __a    :	int									=						(
     LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE__       ,		'scaled_dot_product_attention'		) else LoRAAttnProcessor
 )
 for name, module in text_encoder.named_modules():
  if name.endswith(SCREAMING_SNAKE_CASE__		):
   __a    :	Dict									=						lora_attn_processor_class(
       hidden_size=module.out_proj.out_features       ,		cross_attention_dim=SCREAMING_SNAKE_CASE__		)
 return text_lora_attn_procs






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	Tuple									=						create_text_encoder_lora_attn_procs(SCREAMING_SNAKE_CASE__		)
 __a    :	Dict									=						AttnProcsLayers(SCREAMING_SNAKE_CASE__		)
 return text_encoder_lora_layers






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__=False		):
 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    :	Optional[int]									=						(
        torch.randn_like(layer_module.up.weight		)
        if randn_weight
        else torch.zeros_like(layer_module.up.weight		)
    )
    __a    :	int									=						torch.nn.Parameter(SCREAMING_SNAKE_CASE__		)




class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   def    __magic_name__    ( self			)    ->   int:
    torch.manual_seed(0			)
    __a    :	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    :	List[Any]									=						DDIMScheduler(
        beta_start=0.00_085   ,   beta_end=0.012   ,   beta_schedule='scaled_linear'   ,   clip_sample=_A   ,   set_alpha_to_one=_A   ,   steps_offset=1   ,   )
    torch.manual_seed(0			)
    __a    :	Optional[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   ,   )
    __a    :	Union[str, Any]									=						CLIPTextConfig(
        bos_token_id=0   ,   eos_token_id=2   ,   hidden_size=32   ,   intermediate_size=37   ,   layer_norm_eps=1E-0_5   ,   num_attention_heads=4   ,   num_hidden_layers=5   ,   pad_token_id=1   ,   vocab_size=1000   ,   )
    __a    :	List[Any]									=						CLIPTextModel(_A			)
    __a    :	Dict									=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

    __a			,    __a    :	Optional[int]									=						create_unet_lora_layers(_A			)
    __a    :	List[Any]									=						create_text_encoder_lora_layers(_A			)

    __a    :	str									=						{
        'unet': unet,
        'scheduler': scheduler,
        'vae': vae,
        'text_encoder': text_encoder,
        'tokenizer': tokenizer,
        'safety_checker': None,
        'feature_extractor': None,
    }
    __a    :	Optional[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    __magic_name__    ( self			)    ->   Optional[Any]:
    __a    :	int									=						1
    __a    :	Tuple									=						10
    __a    :	int									=						4
    __a    :	List[str]									=						(32, 32)

    __a    :	Tuple									=						torch.manual_seed(0			)
    __a    :	Tuple									=						floats_tensor((batch_size, num_channels) + sizes			)
    __a    :	Tuple									=						torch.randint(1   ,   _A   ,   size=(batch_size, sequence_length)   ,   generator=_A			)

    __a    :	Union[str, 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    __magic_name__    ( self			)    ->   Optional[int]:
    __a    :	Optional[Any]									=						77

    __a    :	Union[str, Any]									=						torch.randint(2   ,   56   ,   size=(1, max_seq_length)   ,   generator=torch.manual_seed(0			)			)

    __a    :	Optional[int]									=						{}
    __a    :	Tuple									=						inputs
    return prepared_inputs



   def    __magic_name__    ( self   ,   _A			)    ->   Optional[int]:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    LoraLoaderMixin.save_lora_weights(
        save_directory=_A   ,   unet_lora_layers=lora_components['unet_lora_layers']   ,   text_encoder_lora_layers=lora_components['text_encoder_lora_layers']   ,   )
    self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.bin'			)			)			)



   def    __magic_name__    ( self			)    ->   str:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    __a    :	List[Any]									=						StableDiffusionPipeline(**_A			)
    __a    :	List[Any]									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	List[Any]									=						self.get_dummy_inputs()

    __a    :	Dict									=						sd_pipe(**_A			).images
    __a    :	Optional[int]									=						original_images[0, -3:, -3:, -1]

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

    __a    :	str									=						sd_pipe(**_A			).images
    __a    :	Optional[Any]									=						lora_images[0, -3:, -3:, -1]

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



   def    __magic_name__    ( self			)    ->   Tuple:
    __a			,    __a    :	List[str]									=						self.get_dummy_components()
    __a    :	Any									=						StableDiffusionPipeline(**_A			)
    __a    :	str									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

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

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

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

    __a    :	str									=						sd_pipe(**_A			).images
    __a    :	int									=						lora_images[0, -3:, -3:, -1]

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



   def    __magic_name__    ( self			)    ->   Optional[Any]:
    __a			,    __a    :	Optional[int]									=						self.get_dummy_components()
    __a    :	List[Any]									=						lora_components['unet_lora_attn_procs']
    __a    :	Union[str, Any]									=						StableDiffusionPipeline(**_A			)
    __a    :	Optional[Any]									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	Union[str, Any]									=						self.get_dummy_inputs()

    __a    :	List[Any]									=						sd_pipe(**_A			).images
    __a    :	Union[str, Any]									=						original_images[0, -3:, -3:, -1]

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

    __a    :	Optional[Any]									=						sd_pipe(**_A			).images
    __a    :	Any									=						lora_images[0, -3:, -3:, -1]

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



   def    __magic_name__    ( self			)    ->   int:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    __a    :	Optional[int]									=						StableDiffusionPipeline(**_A			)

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

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

    # create lora_attn_procs with zeroed out up.weights
    __a    :	int									=						create_text_encoder_lora_attn_procs(pipe.text_encoder			)
    set_lora_up_weights(_A   ,   randn_weight=_A			)

    # monkey patch
    pipe._modify_text_encoder(_A			)

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

    # inference with lora
    __a    :	Union[str, Any]									=						pipe.text_encoder(**_A			)[0]
    assert outputs_with_lora.shape == (1, 77, 32)

    assert torch.allclose(
        _A   ,   _A			), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

    # create lora_attn_procs with randn up.weights
    __a    :	Optional[int]									=						create_text_encoder_lora_attn_procs(pipe.text_encoder			)
    set_lora_up_weights(_A   ,   randn_weight=_A			)

    # monkey patch
    pipe._modify_text_encoder(_A			)

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

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

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



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a			,    __a    :	List[str]									=						self.get_dummy_components()
    __a    :	str									=						StableDiffusionPipeline(**_A			)

    __a    :	Tuple									=						self.get_dummy_tokens()

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

    # create lora_attn_procs with randn up.weights
    __a    :	Optional[int]									=						create_text_encoder_lora_attn_procs(pipe.text_encoder			)
    set_lora_up_weights(_A   ,   randn_weight=_A			)

    # monkey patch
    pipe._modify_text_encoder(_A			)

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

    # inference with lora
    __a    :	int									=						pipe.text_encoder(**_A			)[0]
    assert outputs_with_lora.shape == (1, 77, 32)

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

    # remove monkey patch
    pipe._remove_text_encoder_monkey_patch()

    # inference with removed lora
    __a    :	Union[str, Any]									=						pipe.text_encoder(**_A			)[0]
    assert outputs_without_lora_removed.shape == (1, 77, 32)

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



   def    __magic_name__    ( self			)    ->   Dict:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    __a    :	Optional[Any]									=						StableDiffusionPipeline(**_A			)
    __a    :	int									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

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

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

    __a    :	int									=						sd_pipe(**_A			).images
    __a    :	Any									=						lora_images[0, -3:, -3:, -1]

    __a    :	Optional[int]									=						sd_pipe(**_A   ,   cross_attention_kwargs={'scale': 0.5}			).images
    __a    :	str									=						lora_images_with_scale[0, -3:, -3:, -1]

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



   def    __magic_name__    ( self			)    ->   str:
    with tempfile.TemporaryDirectory() as tmpdirname:
     self.create_lora_weight_file(_A			)

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

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

            # load LoRA weight file
     sd_pipe.load_lora_weights(_A			)

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



   @unittest.skipIf(torch_device != 'cuda'   ,   'This test is supposed to run on GPU'			)
   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    with tempfile.TemporaryDirectory() as tmpdirname:
     self.create_lora_weight_file(_A			)

     __a			,    __a    :	Optional[int]									=						self.get_dummy_components()
     __a    :	Tuple									=						StableDiffusionPipeline(**_A			)
     __a    :	Optional[int]									=						sd_pipe.to(_A			)
     sd_pipe.set_progress_bar_config(disable=_A			)

     # enable XFormers
     sd_pipe.enable_xformers_memory_efficient_attention()

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

            # load LoRA weight file
     sd_pipe.load_lora_weights(_A			)

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



   @unittest.skipIf(torch_device != 'cuda'   ,   'This test is supposed to run on GPU'			)
   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a			,    __a    :	Union[str, Any]									=						self.get_dummy_components()
    __a    :	Tuple									=						StableDiffusionPipeline(**_A			)
    __a    :	str									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	Optional[Any]									=						self.get_dummy_inputs()

    # enable XFormers
    sd_pipe.enable_xformers_memory_efficient_attention()

    __a    :	str									=						sd_pipe(**_A			).images
    __a    :	str									=						original_images[0, -3:, -3:, -1]

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

    __a    :	Union[str, Any]									=						sd_pipe(**_A			).images
    __a    :	str									=						lora_images[0, -3:, -3:, -1]

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




