

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 				A_					(							a					):

      """simple docstring"""



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

def 				A_					(							a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Tuple          =       {}
      SCREAMING_SNAKE_CASE_			:					Dict          =       (
          LoRAAttnProcessor2_0 if hasattr(a   ,				'scaled_dot_product_attention'					) else LoRAAttnProcessor
      )
      for name, module in text_encoder.named_modules():
            if name.endswith(a					):
                  SCREAMING_SNAKE_CASE_			:					str          =       lora_attn_processor_class(
                      hidden_size=module.out_proj.out_features   ,				cross_attention_dim=a					)
      return text_lora_attn_procs

def 				A_					(							a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       create_text_encoder_lora_attn_procs(a					)
      SCREAMING_SNAKE_CASE_			:					List[str]          =       AttnProcsLayers(a					)
      return text_encoder_lora_layers

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



class 	_A						(					unittest.TestCase):

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        torch.manual_seed(0   )
        SCREAMING_SNAKE_CASE_			:					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	,   )
        SCREAMING_SNAKE_CASE_			:					Tuple          =       DDIMScheduler(
            beta_start=0.00085	,   beta_end=0.012	,   beta_schedule='scaled_linear'	,   clip_sample=_SCREAMING_SNAKE_CASE	,   set_alpha_to_one=_SCREAMING_SNAKE_CASE	,   steps_offset=1	,   )
        torch.manual_seed(0   )
        SCREAMING_SNAKE_CASE_			:					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	,   )
        SCREAMING_SNAKE_CASE_			:					Optional[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=1000	,   )
        SCREAMING_SNAKE_CASE_			:					Optional[int]          =       CLIPTextModel(_SCREAMING_SNAKE_CASE   )
        SCREAMING_SNAKE_CASE_			:					Tuple          =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					str          =       create_unet_lora_layers(_SCREAMING_SNAKE_CASE   )
        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       create_text_encoder_lora_layers(_SCREAMING_SNAKE_CASE   )

        SCREAMING_SNAKE_CASE_			:					List[Any]          =       {
            'unet': unet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }
        SCREAMING_SNAKE_CASE_			:					int          =       {
            '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 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       1
        SCREAMING_SNAKE_CASE_			:					Optional[int]          =       10
        SCREAMING_SNAKE_CASE_			:					str          =       4
        SCREAMING_SNAKE_CASE_			:					int          =       (32, 32)

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

        SCREAMING_SNAKE_CASE_			:					Optional[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 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       77

        SCREAMING_SNAKE_CASE_			:					Optional[int]          =       torch.randint(2	,   56	,   size=(1, max_seq_length)	,   generator=torch.manual_seed(0   )   )

        SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       {}
        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       inputs
        return prepared_inputs

  def 	UpperCAmelCase      (			self	,   _SCREAMING_SNAKE_CASE   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					Dict          =       self.get_dummy_components()
        LoraLoaderMixin.save_lora_weights(
            save_directory=_SCREAMING_SNAKE_CASE	,   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(_SCREAMING_SNAKE_CASE	,   'pytorch_lora_weights.bin'   )   )   )

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					int          =       self.get_dummy_components()
        SCREAMING_SNAKE_CASE_			:					int          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )
        SCREAMING_SNAKE_CASE_			:					List[Any]          =       sd_pipe.to(_SCREAMING_SNAKE_CASE   )
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					Optional[int]          =       self.get_dummy_inputs()

        SCREAMING_SNAKE_CASE_			:					List[str]          =       sd_pipe(**_SCREAMING_SNAKE_CASE   ).images
        SCREAMING_SNAKE_CASE_			:					Optional[int]          =       original_images[0, -3:, -3:, -1]

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

        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       sd_pipe(**_SCREAMING_SNAKE_CASE   ).images
        SCREAMING_SNAKE_CASE_			:					List[str]          =       lora_images[0, -3:, -3:, -1]

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

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







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

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

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

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

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

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

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					Optional[int]          =       self.get_dummy_components()
        SCREAMING_SNAKE_CASE_			:					str          =       lora_components['unet_lora_attn_procs']
        SCREAMING_SNAKE_CASE_			:					Dict          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )
        SCREAMING_SNAKE_CASE_			:					Tuple          =       sd_pipe.to(_SCREAMING_SNAKE_CASE   )
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

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

        SCREAMING_SNAKE_CASE_			:					List[str]          =       sd_pipe(**_SCREAMING_SNAKE_CASE   ).images
        SCREAMING_SNAKE_CASE_			:					Any          =       original_images[0, -3:, -3:, -1]

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

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

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

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					str          =       self.get_dummy_components()
        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )

        SCREAMING_SNAKE_CASE_			:					int          =       self.get_dummy_tokens()

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

        # create lora_attn_procs with zeroed out up.weights
        SCREAMING_SNAKE_CASE_			:					List[str]          =       create_text_encoder_lora_attn_procs(pipe.text_encoder   )
        set_lora_up_weights(_SCREAMING_SNAKE_CASE	,   randn_weight=_SCREAMING_SNAKE_CASE   )

        # monkey patch
        pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE   )

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

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

        assert torch.allclose(
            _SCREAMING_SNAKE_CASE	,   _SCREAMING_SNAKE_CASE   ), "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
        SCREAMING_SNAKE_CASE_			:					Optional[int]          =       create_text_encoder_lora_attn_procs(pipe.text_encoder   )
        set_lora_up_weights(_SCREAMING_SNAKE_CASE	,   randn_weight=_SCREAMING_SNAKE_CASE   )

        # monkey patch
        pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE   )

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

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

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

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       self.get_dummy_components()
        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )

        SCREAMING_SNAKE_CASE_			:					Any          =       self.get_dummy_tokens()

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

        # create lora_attn_procs with randn up.weights
        SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       create_text_encoder_lora_attn_procs(pipe.text_encoder   )
        set_lora_up_weights(_SCREAMING_SNAKE_CASE	,   randn_weight=_SCREAMING_SNAKE_CASE   )

        # monkey patch
        pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE   )

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

        # inference with lora
        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       pipe.text_encoder(**_SCREAMING_SNAKE_CASE   )[0]
        assert outputs_with_lora.shape == (1, 77, 32)

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

        # remove monkey patch
        pipe._remove_text_encoder_monkey_patch()

        # inference with removed lora
        SCREAMING_SNAKE_CASE_			:					List[str]          =       pipe.text_encoder(**_SCREAMING_SNAKE_CASE   )[0]
        assert outputs_without_lora_removed.shape == (1, 77, 32)

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

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					List[str]          =       self.get_dummy_components()
        SCREAMING_SNAKE_CASE_			:					int          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )
        SCREAMING_SNAKE_CASE_			:					str          =       sd_pipe.to(_SCREAMING_SNAKE_CASE   )
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

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

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

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

        SCREAMING_SNAKE_CASE_			:					Tuple          =       sd_pipe(**_SCREAMING_SNAKE_CASE	,   cross_attention_kwargs={'scale': 0.5}   ).images
        SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       lora_images_with_scale[0, -3:, -3:, -1]

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

  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







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

              SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					Tuple          =       self.get_dummy_components()
              SCREAMING_SNAKE_CASE_			:					str          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )
              SCREAMING_SNAKE_CASE_			:					int          =       sd_pipe.to(_SCREAMING_SNAKE_CASE   )
              sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

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

            # load LoRA weight file
              sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE   )

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

  @unittest.skipIf(torch_device != 'cuda'	,   'This test is supposed to run on GPU'   )
  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







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

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

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

            # load LoRA weight file
              sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE   )

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



  @unittest.skipIf(torch_device != 'cuda'	,   'This test is supposed to run on GPU'   )
  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			:					Tuple          =       self.get_dummy_components()
        SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE   )
        SCREAMING_SNAKE_CASE_			:					List[Any]          =       sd_pipe.to(_SCREAMING_SNAKE_CASE   )
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

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

        # enable XFormers
        sd_pipe.enable_xformers_memory_efficient_attention()

        SCREAMING_SNAKE_CASE_			:					Dict          =       sd_pipe(**_SCREAMING_SNAKE_CASE   ).images
        SCREAMING_SNAKE_CASE_			:					str          =       original_images[0, -3:, -3:, -1]

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

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

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









from math import factorial

def 				A_					(							a   ,				a					):

      """simple docstring"""



      return factorial(a					) / (factorial(a					) * factorial(n - r					))

def 				A_					(							):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       0

      for i in range(1   ,				1_0_1					):
            for j in range(1   ,				i + 1					):
                  if combinations(a   ,				a					) > 1e6:
                        total += 1
      return total


if __name__ == "__main__":
    print(solution())






