code: 
  
  
  
  
  
  '''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		(		lowercase			)      ->      int:
  			__lowerCAmelCase      		=       {}
  			for name in unet.attn_processors.keys():
  						__lowerCAmelCase      		=       None if name.endswith("""attn1.processor"""			) else unet.config.cross_attention_dim
  						if name.startswith("""mid_block"""			):
  									__lowerCAmelCase      		=       unet.config.block_out_channels[-1]
  						elif name.startswith("""up_blocks"""			):
  									__lowerCAmelCase      		=       int(name[len("""up_blocks."""			)]			)
  									__lowerCAmelCase      		=       list(reversed(unet.config.block_out_channels			)			)[block_id]
  						elif name.startswith("""down_blocks"""			):
  									__lowerCAmelCase      		=       int(name[len("""down_blocks."""			)]			)
  									__lowerCAmelCase      		=       unet.config.block_out_channels[block_id]
  						__lowerCAmelCase      		=       (
  						    LoRAAttnProcessor2_0 if hasattr(lowercase      ,			"""scaled_dot_product_attention"""			) else LoRAAttnProcessor
  						)
  						__lowerCAmelCase      		=       lora_attn_processor_class(
  						    hidden_size=lowercase      ,			cross_attention_dim=lowercase			)
  			__lowerCAmelCase      		=       AttnProcsLayers(lowercase			)
  			return lora_attn_procs, unet_lora_layers
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      Optional[Any]:
  			__lowerCAmelCase      		=       {}
  			__lowerCAmelCase      		=       (
  			    LoRAAttnProcessor2_0 if hasattr(lowercase      ,			"""scaled_dot_product_attention"""			) else LoRAAttnProcessor
  			)
  			for name, module in text_encoder.named_modules():
  						if name.endswith(lowercase			):
  									__lowerCAmelCase      		=       lora_attn_processor_class(
  									    hidden_size=module.out_proj.out_features      ,			cross_attention_dim=lowercase			)
  			return text_lora_attn_procs
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      Union[str, Any]:
  			__lowerCAmelCase      		=       create_text_encoder_lora_attn_procs(lowercase			)
  			__lowerCAmelCase      		=       AttnProcsLayers(lowercase			)
  			return text_encoder_lora_layers
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase      ,			lowercase=False			)      ->      Dict:
  
  
  
  
  
  
  
  			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      		=       (
  												    torch.randn_like(layer_module.up.weight			)
  												    if randn_weight
  												    else torch.zeros_like(layer_module.up.weight			)
  												)
  												__lowerCAmelCase      		=       torch.nn.Parameter(lowercase			)
  
  
  
  
  
  
  
  class 					_UpperCAmelCase							(		unittest.TestCase     ):
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					torch.manual_seed(0    )
  					__lowerCAmelCase      		=       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      		=       DDIMScheduler(
  					    beta_start=0.0_0085,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    )
  					__lowerCAmelCase      		=       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      		=       CLIPTextConfig(
  					    bos_token_id=0,eos_token_id=2,hidden_size=32,intermediate_size=37,layer_norm_eps=1e-05,num_attention_heads=4,num_hidden_layers=5,pad_token_id=1,vocab_size=10_00,)
  					__lowerCAmelCase      		=       CLIPTextModel(__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       create_unet_lora_layers(__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       create_text_encoder_lora_layers(__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       {
  					    """unet""": unet,
  					    """scheduler""": scheduler,
  					    """vae""": vae,
  					    """text_encoder""": text_encoder,
  					    """tokenizer""": tokenizer,
  					    """safety_checker""": None,
  					    """feature_extractor""": None,
  					}
  					__lowerCAmelCase      		=       {
  					    """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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       1
  					__lowerCAmelCase      		=       10
  					__lowerCAmelCase      		=       4
  					__lowerCAmelCase      		=       (32, 32)
  
  					__lowerCAmelCase      		=       torch.manual_seed(0    )
  					__lowerCAmelCase      		=       floats_tensor((batch_size, num_channels) + sizes    )
  					__lowerCAmelCase      		=       torch.randint(1,__SCREAMING_SNAKE_CASE,size=(batch_size, sequence_length),generator=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       {
  					    """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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       77
  
  					__lowerCAmelCase      		=       torch.randint(2,56,size=(1, max_seq_length),generator=torch.manual_seed(0    )    )
  
  					__lowerCAmelCase      		=       {}
  					__lowerCAmelCase      		=       inputs
  					return prepared_inputs
  		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       sd_pipe.to(__SCREAMING_SNAKE_CASE    )
  					sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase		, __lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_inputs()
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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    )
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       sd_pipe.to(__SCREAMING_SNAKE_CASE    )
  					sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase		, __lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_inputs()
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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    )
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       lora_components["""unet_lora_attn_procs"""]
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       sd_pipe.to(__SCREAMING_SNAKE_CASE    )
  					sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase		, __lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_inputs()
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       original_images[0, -3:, -3:, -1]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								__lowerCAmelCase      		=       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    )
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       self.get_dummy_tokens()
  
  					# inference without lora
  					__lowerCAmelCase      		=       pipe.text_encoder(**__SCREAMING_SNAKE_CASE    )[0]
  					assert outputs_without_lora.shape == (1, 77, 32)
  
  					# create lora_attn_procs with zeroed out up.weights
  					__lowerCAmelCase      		=       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
  					__lowerCAmelCase      		=       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
  					__lowerCAmelCase      		=       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
  					__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       self.get_dummy_tokens()
  
  					# inference without lora
  					__lowerCAmelCase      		=       pipe.text_encoder(**__SCREAMING_SNAKE_CASE    )[0]
  					assert outputs_without_lora.shape == (1, 77, 32)
  
  					# create lora_attn_procs with randn up.weights
  					__lowerCAmelCase      		=       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
  					__lowerCAmelCase      		=       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
  					__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       sd_pipe.to(__SCREAMING_SNAKE_CASE    )
  					sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase		, __lowerCAmelCase		, __lowerCAmelCase      		=       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    )
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       lora_images[0, -3:, -3:, -1]
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE,cross_attention_kwargs={"""scale""": 0.5}    ).images
  					__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								self.create_lora_weight_file(__SCREAMING_SNAKE_CASE    )
  
  								__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  								__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  								__lowerCAmelCase      		=       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    ):
  														__lowerCAmelCase      		=       (
  														    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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								self.create_lora_weight_file(__SCREAMING_SNAKE_CASE    )
  
  								__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  								__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  								__lowerCAmelCase      		=       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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_components()
  					__lowerCAmelCase      		=       StableDiffusionPipeline(**__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       sd_pipe.to(__SCREAMING_SNAKE_CASE    )
  					sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase		, __lowerCAmelCase		, __lowerCAmelCase      		=       self.get_dummy_inputs()
  
  					# enable XFormers
  					sd_pipe.enable_xformers_memory_efficient_attention()
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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    )
  
  					__lowerCAmelCase      		=       sd_pipe(**__SCREAMING_SNAKE_CASE    ).images
  					__lowerCAmelCase      		=       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    )    )    )
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  from cva import destroyAllWindows, imread, imshow, waitKey
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase      ,			lowercase			)      ->      int:
  			__lowerCAmelCase		, __lowerCAmelCase      		=       img.shape[0], img.shape[1]
  
  			def to_grayscale(lowercase      ,			lowercase      ,			lowercase			):
  						return 0.21_26 * red + 0.5_87 * green + 0.1_14 * blue
  
  			def normalize(lowercase			):
  						return min(lowercase      ,			255			)
  
  			for i in range(lowercase			):
  						for j in range(lowercase			):
  									__lowerCAmelCase      		=       int(to_grayscale(*img[i][j]			)			)
  									__lowerCAmelCase      		=       [
  									    normalize(lowercase			),
  									    normalize(greyscale + factor			),
  									    normalize(greyscale + 2 * factor			),
  									]
  
  			return img
  
  
  if __name__ == "__main__":
  	# read original image
  	_a      :				Any											=					{
  	    percentage: imread("""image_data/lena.jpg""", 1) for percentage in (1_0, 2_0, 3_0, 4_0)
  	}
  
  	for percentage, img in images.items():
  		make_sepia(img, percentage)
  
  	for percentage, img in images.items():
  		imshow(f'Original image with sepia (factor: {percentage})', img)
  
  	waitKey(0)
  	destroyAllWindows()
  
  