





import datasets

from .evaluate import (
    apply_no_ans_threshold,
    find_all_best_thresh,
    get_raw_scores,
    make_eval_dict,
    make_qid_to_has_ans,
    merge_eval,
)


__UpperCAmelCase						=      '\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n'

__UpperCAmelCase						=      '\nThis metric wrap the official scoring script for version 2 of the Stanford Question\nAnswering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n\nSQuAD2.0 combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions\nwritten adversarially by crowdworkers to look similar to answerable ones.\nTo do well on SQuAD2.0, systems must not only answer questions when possible, but also\ndetermine when no answer is supported by the paragraph and abstain from answering.\n'

__UpperCAmelCase						=      '\nComputes SQuAD v2 scores (F1 and EM).\nArgs:\n    predictions: List of triple for question-answers to score with the following elements:\n        - the question-answer \'id\' field as given in the references (see below)\n        - the text of the answer\n        - the probability that the question has no answer\n    references: List of question-answers dictionaries with the following key-values:\n            - \'id\': id of the question-answer pair (see above),\n            - \'answers\': a list of Dict {\'text\': text of the answer as a string}\n    no_answer_threshold: float\n        Probability threshold to decide that a question has no answer.\nReturns:\n    \'exact\': Exact match (the normalized answer exactly match the gold answer)\n    \'f1\': The F-score of predicted tokens versus the gold answer\n    \'total\': Number of score considered\n    \'HasAns_exact\': Exact match (the normalized answer exactly match the gold answer)\n    \'HasAns_f1\': The F-score of predicted tokens versus the gold answer\n    \'HasAns_total\': Number of score considered\n    \'NoAns_exact\': Exact match (the normalized answer exactly match the gold answer)\n    \'NoAns_f1\': The F-score of predicted tokens versus the gold answer\n    \'NoAns_total\': Number of score considered\n    \'best_exact\': Best exact match (with varying threshold)\n    \'best_exact_thresh\': No-answer probability threshold associated to the best exact match\n    \'best_f1\': Best F1 (with varying threshold)\n    \'best_f1_thresh\': No-answer probability threshold associated to the best F1\nExamples:\n\n    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\', \'no_answer_probability\': 0.}]\n    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]\n    >>> squad_v2_metric = datasets.load_metric("squad_v2")\n    >>> results = squad_v2_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'exact\': 100.0, \'f1\': 100.0, \'total\': 1, \'HasAns_exact\': 100.0, \'HasAns_f1\': 100.0, \'HasAns_total\': 1, \'best_exact\': 100.0, \'best_exact_thresh\': 0.0, \'best_f1\': 100.0, \'best_f1_thresh\': 0.0}\n'

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,_KWARGS_DESCRIPTION      )
class 		__a							(	datasets.Metric      ):



       def  A							(     self	:   List[Any]			):
           return datasets.MetricInfo(
               description=_DESCRIPTION					,			citation=_CITATION					,			inputs_description=_KWARGS_DESCRIPTION					,			features=datasets.Features(
                   {
                       """predictions""": {
                           """id""": datasets.Value("""string"""			),
                           """prediction_text""": datasets.Value("""string"""			),
                           """no_answer_probability""": datasets.Value("""float32"""			),
                       },
                       """references""": {
                           """id""": datasets.Value("""string"""			),
                           """answers""": datasets.features.Sequence(
                               {"""text""": datasets.Value("""string"""			), """answer_start""": datasets.Value("""int32"""			)}			),
                       },
                   }			)					,			codebase_urls=["""https://rajpurkar.github.io/SQuAD-explorer/"""]					,			reference_urls=["""https://rajpurkar.github.io/SQuAD-explorer/"""]					,			)



       def  A							(     self	:   Any					,			UpperCAmelCase	:   str					,			UpperCAmelCase	:   Tuple					,			UpperCAmelCase	:   List[Any]=1.0			):
           lowerCAmelCase_					:	Dict						=   {p["""id"""]: p["""no_answer_probability"""] for p in predictions}
           lowerCAmelCase_					:	Union[str, Any]						=   [{"""paragraphs""": [{"""qas""": references}]}]
           lowerCAmelCase_					:	str						=   {p["""id"""]: p["""prediction_text"""] for p in predictions}

           lowerCAmelCase_					:	Optional[int]						=   make_qid_to_has_ans(UpperCAmelCase			)  # maps qid to True/False
           lowerCAmelCase_					:	int						=   [k for k, v in qid_to_has_ans.items() if v]
           lowerCAmelCase_					:	int						=   [k for k, v in qid_to_has_ans.items() if not v]

           lowerCAmelCase_					:	Tuple						=   get_raw_scores(UpperCAmelCase					,			UpperCAmelCase			)
           lowerCAmelCase_					:	List[str]						=   apply_no_ans_threshold(UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase			)
           lowerCAmelCase_					:	List[Any]						=   apply_no_ans_threshold(UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase			)
           lowerCAmelCase_					:	Dict						=   make_eval_dict(UpperCAmelCase					,			UpperCAmelCase			)

           if has_ans_qids:
               lowerCAmelCase_					:	Tuple						=   make_eval_dict(UpperCAmelCase					,			UpperCAmelCase					,			qid_list=UpperCAmelCase			)
               merge_eval(UpperCAmelCase					,			UpperCAmelCase					,			"""HasAns"""			)
           if no_ans_qids:
               lowerCAmelCase_					:	str						=   make_eval_dict(UpperCAmelCase					,			UpperCAmelCase					,			qid_list=UpperCAmelCase			)
               merge_eval(UpperCAmelCase					,			UpperCAmelCase					,			"""NoAns"""			)
           find_all_best_thresh(UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase			)
           return dict(UpperCAmelCase			)









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 			__UpperCamelCase				(			lowercase__	:       nn.Module		)	->      str:
    '''simple docstring'''





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





    lowerCAmelCase_					:	Optional[int]						=   {}
    lowerCAmelCase_					:	str						=   (
        LoRAAttnProcessor2_0 if hasattr(lowercase__		,    """scaled_dot_product_attention"""		) else LoRAAttnProcessor
    )
    for name, module in text_encoder.named_modules():
        if name.endswith(lowercase__		):
            lowerCAmelCase_					:	Optional[int]						=   lora_attn_processor_class(
                hidden_size=module.out_proj.out_features		,    cross_attention_dim=lowercase__		)
    return text_lora_attn_procs
def 			__UpperCamelCase				(			lowercase__	:       nn.Module		)	->      List[str]:
    '''simple docstring'''





    lowerCAmelCase_					:	int						=   create_text_encoder_lora_attn_procs(lowercase__		)
    lowerCAmelCase_					:	str						=   AttnProcsLayers(lowercase__		)
    return text_encoder_lora_layers
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       Union[str, Any]=False		)	->      Any:
    '''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"""		):
                lowerCAmelCase_					:	Union[str, Any]						=   (
                    torch.randn_like(layer_module.up.weight		)
                    if randn_weight
                    else torch.zeros_like(layer_module.up.weight		)
                )
                lowerCAmelCase_					:	Optional[Any]						=   torch.nn.Parameter(lowercase__		)

class 		__a							(	unittest.TestCase      ):



       def  A							(     self	:   List[Any]			):
           torch.manual_seed(0			)
           lowerCAmelCase_					:	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					,			)
           lowerCAmelCase_					:	Dict						=   DDIMScheduler(
               beta_start=0.0_0085					,			beta_end=0.012					,			beta_schedule="""scaled_linear"""					,			clip_sample=UpperCAmelCase					,			set_alpha_to_one=UpperCAmelCase					,			steps_offset=1					,			)
           torch.manual_seed(0			)
           lowerCAmelCase_					:	List[str]						=   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					,			)
           lowerCAmelCase_					:	int						=   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=10_00					,			)
           lowerCAmelCase_					:	str						=   CLIPTextModel(UpperCAmelCase			)
           lowerCAmelCase_					:	Union[str, Any]						=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

           lowerCAmelCase_		,		lowerCAmelCase_					:	Union[str, Any]						=   create_unet_lora_layers(UpperCAmelCase			)
           lowerCAmelCase_					:	int						=   create_text_encoder_lora_layers(UpperCAmelCase			)

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

           lowerCAmelCase_					:	int						=   torch.manual_seed(0			)
           lowerCAmelCase_					:	str						=   floats_tensor((batch_size, num_channels) + sizes			)
           lowerCAmelCase_					:	int						=   torch.randint(1					,			UpperCAmelCase					,			size=(batch_size, sequence_length)					,			generator=UpperCAmelCase			)

           lowerCAmelCase_					:	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  A							(     self	:   Dict			):
           lowerCAmelCase_					:	Union[str, Any]						=   77

           lowerCAmelCase_					:	List[Any]						=   torch.randint(2					,			56					,			size=(1, max_seq_length)					,			generator=torch.manual_seed(0			)			)

           lowerCAmelCase_					:	List[Any]						=   {}
           lowerCAmelCase_					:	Optional[Any]						=   inputs
           return prepared_inputs



       def  A							(     self	:   List[str]					,			UpperCAmelCase	:   List[str]			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	List[Any]						=   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  A							(     self	:   Optional[int]			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	Optional[Any]						=   self.get_dummy_components()
           lowerCAmelCase_					:	Optional[Any]						=   StableDiffusionPipeline(**UpperCAmelCase			)
           lowerCAmelCase_					:	str						=   sd_pipe.to(UpperCAmelCase			)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase			)

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

           lowerCAmelCase_					:	Tuple						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	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			)

           lowerCAmelCase_					:	Any						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	Any						=   lora_images[0, -3:, -3:, -1]

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



       def  A							(     self	:   Tuple			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	Optional[Any]						=   self.get_dummy_components()
           lowerCAmelCase_					:	Union[str, Any]						=   StableDiffusionPipeline(**UpperCAmelCase			)
           lowerCAmelCase_					:	Optional[Any]						=   sd_pipe.to(UpperCAmelCase			)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase			)

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

           lowerCAmelCase_					:	Optional[int]						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	int						=   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			)

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

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



       def  A							(     self	:   Dict			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	Optional[Any]						=   self.get_dummy_components()
           lowerCAmelCase_					:	Any						=   lora_components["""unet_lora_attn_procs"""]
           lowerCAmelCase_					:	str						=   StableDiffusionPipeline(**UpperCAmelCase			)
           lowerCAmelCase_					:	Union[str, Any]						=   sd_pipe.to(UpperCAmelCase			)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase			)

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

           lowerCAmelCase_					:	int						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	int						=   original_images[0, -3:, -3:, -1]

           with tempfile.TemporaryDirectory() as tmpdirname:
               lowerCAmelCase_					:	List[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			)

           lowerCAmelCase_					:	List[str]						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	List[str]						=   lora_images[0, -3:, -3:, -1]

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



       def  A							(     self	:   int			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	Dict						=   self.get_dummy_components()
           lowerCAmelCase_					:	Dict						=   StableDiffusionPipeline(**UpperCAmelCase			)

           lowerCAmelCase_					:	Optional[int]						=   self.get_dummy_tokens()

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

           # create lora_attn_procs with zeroed out up.weights
           lowerCAmelCase_					:	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
           lowerCAmelCase_					:	str						=   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
           lowerCAmelCase_					:	Optional[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
           lowerCAmelCase_					:	Optional[int]						=   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  A							(     self	:   Union[str, Any]			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	Optional[int]						=   self.get_dummy_components()
           lowerCAmelCase_					:	List[Any]						=   StableDiffusionPipeline(**UpperCAmelCase			)

           lowerCAmelCase_					:	Optional[Any]						=   self.get_dummy_tokens()

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

           # create lora_attn_procs with randn up.weights
           lowerCAmelCase_					:	int						=   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
           lowerCAmelCase_					:	List[str]						=   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
           lowerCAmelCase_					:	Tuple						=   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  A							(     self	:   Any			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	Any						=   self.get_dummy_components()
           lowerCAmelCase_					:	int						=   StableDiffusionPipeline(**UpperCAmelCase			)
           lowerCAmelCase_					:	int						=   sd_pipe.to(UpperCAmelCase			)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase			)

           lowerCAmelCase_		,		lowerCAmelCase_		,		lowerCAmelCase_					:	Optional[int]						=   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			)

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

           lowerCAmelCase_					:	Dict						=   sd_pipe(**UpperCAmelCase					,			cross_attention_kwargs={"""scale""": 0.5}			).images
           lowerCAmelCase_					:	str						=   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  A							(     self	:   List[str]			):
           with tempfile.TemporaryDirectory() as tmpdirname:
               self.create_lora_weight_file(UpperCAmelCase			)

               lowerCAmelCase_		,		lowerCAmelCase_					:	List[str]						=   self.get_dummy_components()
               lowerCAmelCase_					:	int						=   StableDiffusionPipeline(**UpperCAmelCase			)
               lowerCAmelCase_					:	Union[str, 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			):
                       lowerCAmelCase_					:	Optional[int]						=   (
                           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  A							(     self	:   Any			):
           with tempfile.TemporaryDirectory() as tmpdirname:
               self.create_lora_weight_file(UpperCAmelCase			)

               lowerCAmelCase_		,		lowerCAmelCase_					:	List[str]						=   self.get_dummy_components()
               lowerCAmelCase_					:	Any						=   StableDiffusionPipeline(**UpperCAmelCase			)
               lowerCAmelCase_					:	List[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  A							(     self	:   List[str]			):
           lowerCAmelCase_		,		lowerCAmelCase_					:	int						=   self.get_dummy_components()
           lowerCAmelCase_					:	Optional[int]						=   StableDiffusionPipeline(**UpperCAmelCase			)
           lowerCAmelCase_					:	Dict						=   sd_pipe.to(UpperCAmelCase			)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase			)

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

           # enable XFormers
           sd_pipe.enable_xformers_memory_efficient_attention()

           lowerCAmelCase_					:	Any						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	Union[str, 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			)

           lowerCAmelCase_					:	Optional[Any]						=   sd_pipe(**UpperCAmelCase			).images
           lowerCAmelCase_					:	Union[str, Any]						=   lora_images[0, -3:, -3:, -1]

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


