



"""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  (   __UpperCamelCase ):
 '''simple docstring'''





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





 UpperCAmelCase__   :					Union[str, Any]   				=   {}
 UpperCAmelCase__   :					List[str]   				=   (
     LoRAAttnProcessor2_0 if hasattr(lowercase_							,      """scaled_dot_product_attention""" ) else LoRAAttnProcessor
 )
 for name, module in text_encoder.named_modules():
  if name.endswith(lowercase_ ):
   UpperCAmelCase__   :					Optional[int]   				=   lora_attn_processor_class(
       hidden_size=module.out_proj.out_features							,      cross_attention_dim=lowercase_ )
 return text_lora_attn_procs
def 					lowerCAmelCase  (   __UpperCamelCase ):
 '''simple docstring'''





 UpperCAmelCase__   :					List[str]   				=   create_text_encoder_lora_attn_procs(lowercase_ )
 UpperCAmelCase__   :					str   				=   AttnProcsLayers(lowercase_ )
 return text_encoder_lora_layers
def 					lowerCAmelCase  (   __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""" ):
    UpperCAmelCase__   :					Optional[Any]   				=   (
        torch.randn_like(layer_module.up.weight )
        if randn_weight
        else torch.zeros_like(layer_module.up.weight )
    )
    UpperCAmelCase__   :					Tuple   				=   torch.nn.Parameter(lowercase_ )







class        __lowercase     (      unittest.TestCase   ):

  def 				__lowercase    (					self						:     List[str]      ):






   '''simple docstring'''
   torch.manual_seed(0      )
   UpperCAmelCase__   :					int   				=   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   ,)
   UpperCAmelCase__   :					Union[str, Any]   				=   DDIMScheduler(
       beta_start=0.0_0_0_8_5   ,beta_end=0.0_1_2   ,beta_schedule="""scaled_linear"""   ,clip_sample=lowerCAmelCase__   ,set_alpha_to_one=lowerCAmelCase__   ,steps_offset=1   ,)
   torch.manual_seed(0      )
   UpperCAmelCase__   :					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   ,)
   UpperCAmelCase__   :					Any   				=   CLIPTextConfig(
       bos_token_id=0   ,eos_token_id=2   ,hidden_size=32   ,intermediate_size=37   ,layer_norm_eps=1e-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=1_000   ,)
   UpperCAmelCase__   :					Tuple   				=   CLIPTextModel(lowerCAmelCase__      )
   UpperCAmelCase__   :					int   				=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""      )

   UpperCAmelCase__				, UpperCAmelCase__   :					List[str]   				=   create_unet_lora_layers(lowerCAmelCase__      )
   UpperCAmelCase__   :					Optional[int]   				=   create_text_encoder_lora_layers(lowerCAmelCase__      )

   UpperCAmelCase__   :					Dict   				=   {
       """unet""": unet,
       """scheduler""": scheduler,
       """vae""": vae,
       """text_encoder""": text_encoder,
       """tokenizer""": tokenizer,
       """safety_checker""": None,
       """feature_extractor""": None,
   }
   UpperCAmelCase__   :					str   				=   {
       """unet_lora_layers""": unet_lora_layers,
       """text_encoder_lora_layers""": text_encoder_lora_layers,
       """unet_lora_attn_procs""": unet_lora_attn_procs,
   }
   return pipeline_components, lora_components

  def 				__lowercase    (					self						:     Union[str, Any]      ):






   '''simple docstring'''
   UpperCAmelCase__   :					int   				=   1
   UpperCAmelCase__   :					str   				=   10
   UpperCAmelCase__   :					Tuple   				=   4
   UpperCAmelCase__   :					Union[str, Any]   				=   (32, 32)

   UpperCAmelCase__   :					int   				=   torch.manual_seed(0      )
   UpperCAmelCase__   :					Optional[int]   				=   floats_tensor((batch_size, num_channels) + sizes      )
   UpperCAmelCase__   :					Tuple   				=   torch.randint(1   ,lowerCAmelCase__   ,size=(batch_size, sequence_length)   ,generator=lowerCAmelCase__      )

   UpperCAmelCase__   :					str   				=   {
       """prompt""": """A painting of a squirrel eating a burger""",
       """generator""": generator,
       """num_inference_steps""": 2,
       """guidance_scale""": 6.0,
       """output_type""": """numpy""",
   }

   return noise, input_ids, pipeline_inputs

   # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb

  def 				__lowercase    (					self						:     str      ):






   '''simple docstring'''
   UpperCAmelCase__   :					str   				=   77

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

   UpperCAmelCase__   :					Optional[Any]   				=   {}
   UpperCAmelCase__   :					int   				=   inputs
   return prepared_inputs

  def 				__lowercase    (					self						:     List[str]   ,A						:     Any      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					int   				=   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 				__lowercase    (					self						:     Union[str, Any]      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					List[str]   				=   self.get_dummy_components()
   UpperCAmelCase__   :					int   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
   UpperCAmelCase__   :					Any   				=   sd_pipe.to(lowerCAmelCase__      )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__      )

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

   UpperCAmelCase__   :					Union[str, Any]   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					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__      )

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

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

  def 				__lowercase    (					self						:     Optional[int]      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					Optional[int]   				=   self.get_dummy_components()
   UpperCAmelCase__   :					List[str]   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
   UpperCAmelCase__   :					str   				=   sd_pipe.to(lowerCAmelCase__      )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__      )

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

   UpperCAmelCase__   :					Union[str, Any]   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					Union[str, Any]   				=   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__      )

   UpperCAmelCase__   :					List[Any]   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					Union[str, Any]   				=   lora_images[0, -3:, -3:, -1]

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

  def 				__lowercase    (					self						:     Any      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					Union[str, Any]   				=   self.get_dummy_components()
   UpperCAmelCase__   :					Tuple   				=   lora_components["""unet_lora_attn_procs"""]
   UpperCAmelCase__   :					Union[str, Any]   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
   UpperCAmelCase__   :					Union[str, Any]   				=   sd_pipe.to(lowerCAmelCase__      )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__      )

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

   UpperCAmelCase__   :					Dict   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					Tuple   				=   original_images[0, -3:, -3:, -1]

   with tempfile.TemporaryDirectory() as tmpdirname:
    UpperCAmelCase__   :					Optional[int]   				=   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__      )

   UpperCAmelCase__   :					List[Any]   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					Union[str, Any]   				=   lora_images[0, -3:, -3:, -1]

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

  def 				__lowercase    (					self						:     Optional[int]      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					Optional[Any]   				=   self.get_dummy_components()
   UpperCAmelCase__   :					Any   				=   StableDiffusionPipeline(**lowerCAmelCase__      )

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

   # inference without lora
   UpperCAmelCase__   :					int   				=   pipe.text_encoder(**lowerCAmelCase__      )[0]
   assert outputs_without_lora.shape == (1, 77, 32)

   # create lora_attn_procs with zeroed out up.weights
   UpperCAmelCase__   :					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
   UpperCAmelCase__   :					Optional[int]   				=   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
   UpperCAmelCase__   :					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
   UpperCAmelCase__   :					Optional[int]   				=   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 				__lowercase    (					self						:     int      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					List[str]   				=   self.get_dummy_components()
   UpperCAmelCase__   :					str   				=   StableDiffusionPipeline(**lowerCAmelCase__      )

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

   # inference without lora
   UpperCAmelCase__   :					str   				=   pipe.text_encoder(**lowerCAmelCase__      )[0]
   assert outputs_without_lora.shape == (1, 77, 32)

   # create lora_attn_procs with randn up.weights
   UpperCAmelCase__   :					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
   UpperCAmelCase__   :					Dict   				=   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
   UpperCAmelCase__   :					Any   				=   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 				__lowercase    (					self						:     List[Any]      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					Union[str, Any]   				=   self.get_dummy_components()
   UpperCAmelCase__   :					List[str]   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
   UpperCAmelCase__   :					str   				=   sd_pipe.to(lowerCAmelCase__      )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__      )

   UpperCAmelCase__				, UpperCAmelCase__				, UpperCAmelCase__   :					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__      )

   UpperCAmelCase__   :					Dict   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					str   				=   lora_images[0, -3:, -3:, -1]

   UpperCAmelCase__   :					Optional[Any]   				=   sd_pipe(**lowerCAmelCase__   ,cross_attention_kwargs={"""scale""": 0.5}      ).images
   UpperCAmelCase__   :					Union[str, Any]   				=   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 				__lowercase    (					self						:     Tuple      ):






   '''simple docstring'''
   with tempfile.TemporaryDirectory() as tmpdirname:
    self.create_lora_weight_file(lowerCAmelCase__      )

    UpperCAmelCase__				, UpperCAmelCase__   :					Optional[int]   				=   self.get_dummy_components()
    UpperCAmelCase__   :					Optional[Any]   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
    UpperCAmelCase__   :					List[str]   				=   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__      ):
      UpperCAmelCase__   :					int   				=   (
          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 				__lowercase    (					self						:     Any      ):






   '''simple docstring'''
   with tempfile.TemporaryDirectory() as tmpdirname:
    self.create_lora_weight_file(lowerCAmelCase__      )

    UpperCAmelCase__				, UpperCAmelCase__   :					List[Any]   				=   self.get_dummy_components()
    UpperCAmelCase__   :					Any   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
    UpperCAmelCase__   :					Union[str, 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 				__lowercase    (					self						:     str      ):






   '''simple docstring'''
   UpperCAmelCase__				, UpperCAmelCase__   :					str   				=   self.get_dummy_components()
   UpperCAmelCase__   :					Tuple   				=   StableDiffusionPipeline(**lowerCAmelCase__      )
   UpperCAmelCase__   :					Tuple   				=   sd_pipe.to(lowerCAmelCase__      )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__      )

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

   # enable XFormers
   sd_pipe.enable_xformers_memory_efficient_attention()

   UpperCAmelCase__   :					str   				=   sd_pipe(**lowerCAmelCase__      ).images
   UpperCAmelCase__   :					List[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__      )

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

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








"""simple docstring"""




from __future__ import annotations
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase ):
 '''simple docstring'''





 UpperCAmelCase__				, UpperCAmelCase__   :					Optional[Any]   				=   m - 1, 0
 while i >= 0 and j < n:
  if key == mat[i][j]:
   print(F"Key {key} found at row- {i + 1} column- {j + 1}" )
   return
  if key < mat[i][j]:
   i -= 1
  else:
   j += 1
 print(F"Key {key} not found" )
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 UpperCAmelCase__   :					Union[str, Any]   				=   [[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
 UpperCAmelCase__   :					int   				=   int(input("""Enter the element to be searched:""" ) )
 print(__UpperCamelCase )
 search_in_a_sorted_matrix(__UpperCamelCase							,      len(__UpperCamelCase )							,      len(mat[0] )							,      __UpperCamelCase )


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()





