code: 
  
  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        __SCREAMING_SNAKE_CASE    (      a__						:      nn.Module					)				->							List[Any]:
  	__A   : int								= {}
  	for name in unet.attn_processors.keys():
  		__A   : Union[str, Any]								= None if name.endswith("""attn1.processor"""					) else unet.config.cross_attention_dim
  		if name.startswith("""mid_block"""					):
  			__A   : Tuple								= unet.config.block_out_channels[-1]
  		elif name.startswith("""up_blocks"""					):
  			__A   : List[str]								= int(name[len("""up_blocks."""					)]					)
  			__A   : List[Any]								= list(reversed(unet.config.block_out_channels					)					)[block_id]
  		elif name.startswith("""down_blocks"""					):
  			__A   : Any								= int(name[len("""down_blocks."""					)]					)
  			__A   : int								= unet.config.block_out_channels[block_id]
  		__A   : List[Any]								= (
  		    LoRAAttnProcessor2_0 if hasattr(a__ ,"""scaled_dot_product_attention"""					) else LoRAAttnProcessor
  		)
  		__A   : str								= lora_attn_processor_class(
  		    hidden_size=a__ ,cross_attention_dim=a__					)
  	__A   : Tuple								= AttnProcsLayers(a__					)
  	return lora_attn_procs, unet_lora_layers
  def        __SCREAMING_SNAKE_CASE    (      a__						:      nn.Module					)				->							Tuple:
  	__A   : Any								= {}
  	__A   : List[str]								= (
  	    LoRAAttnProcessor2_0 if hasattr(a__ ,"""scaled_dot_product_attention"""					) else LoRAAttnProcessor
  	)
  	for name, module in text_encoder.named_modules():
  		if name.endswith(a__					):
  			__A   : str								= lora_attn_processor_class(
  			    hidden_size=module.out_proj.out_features ,cross_attention_dim=a__					)
  	return text_lora_attn_procs
  def        __SCREAMING_SNAKE_CASE    (      a__						:      nn.Module					)				->							Optional[int]:
  	__A   : List[str]								= create_text_encoder_lora_attn_procs(a__					)
  	__A   : Union[str, Any]								= AttnProcsLayers(a__					)
  	return text_encoder_lora_layers
  def        __SCREAMING_SNAKE_CASE    (      a__						:      Optional[Any] ,a__						:      Optional[int]=False					)				->							str:
  	for _, attn_proc in text_lora_attn_procs.items():
  		# set up.weights
  		for layer_name, layer_module in attn_proc.named_modules():
  			if layer_name.endswith("""_lora"""					):
  				__A   : Optional[Any]								= (
  				    torch.randn_like(layer_module.up.weight					)
  				    if randn_weight
  				    else torch.zeros_like(layer_module.up.weight					)
  				)
  				__A   : List[str]								= torch.nn.Parameter(a__					)
  
  
  
  
  
  
  
  class     lowerCamelCase_			(  unittest.TestCase  ):
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		torch.manual_seed(0       )
  		__A   : 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				,			)
  		__A   : List[Any]								= DDIMScheduler(
  		    beta_start=0.0_0_0_8_5				,			beta_end=0.0_1_2				,			beta_schedule="""scaled_linear"""				,			clip_sample=__A				,			set_alpha_to_one=__A				,			steps_offset=1				,			)
  		torch.manual_seed(0       )
  		__A   : 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				,			)
  		__A   : Tuple								= CLIPTextConfig(
  		    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1e-0_5				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			)
  		__A   : int								= CLIPTextModel(__A       )
  		__A   : Dict								= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )
  
  		__A						,							__A   : Tuple								= create_unet_lora_layers(__A       )
  		__A   : str								= create_text_encoder_lora_layers(__A       )
  
  		__A   : Tuple								= {
  		    """unet""": unet,
  		    """scheduler""": scheduler,
  		    """vae""": vae,
  		    """text_encoder""": text_encoder,
  		    """tokenizer""": tokenizer,
  		    """safety_checker""": None,
  		    """feature_extractor""": None,
  		}
  		__A   : List[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 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A   : Union[str, Any]								= 1
  		__A   : Optional[int]								= 10
  		__A   : List[Any]								= 4
  		__A   : Optional[Any]								= (32, 32)
  
  		__A   : int								= torch.manual_seed(0       )
  		__A   : str								= floats_tensor((batch_size, num_channels) + sizes       )
  		__A   : List[str]								= torch.randint(1				,			__A				,			size=(batch_size, sequence_length)				,			generator=__A       )
  
  		__A   : Union[str, Any]								= {
  		    """prompt""": """A painting of a squirrel eating a burger""",
  		    """generator""": generator,
  		    """num_inference_steps""": 2,
  		    """guidance_scale""": 6.0,
  		    """output_type""": """numpy""",
  		}
  
  		return noise, input_ids, pipeline_inputs
  
  		# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    int       ):
  		__A   : List[Any]								= 77
  
  		__A   : Optional[Any]								= torch.randint(2				,			56				,			size=(1, max_seq_length)				,			generator=torch.manual_seed(0       )       )
  
  		__A   : int								= {}
  		__A   : Optional[Any]								= inputs
  		return prepared_inputs
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Union[str, Any]				,			__A	:    Any       ):
  		__A						,							__A   : Union[str, Any]								= self.get_dummy_components()
  		LoraLoaderMixin.save_lora_weights(
  		    save_directory=__A				,			unet_lora_layers=lora_components["""unet_lora_layers"""]				,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]				,			)
  		self.assertTrue(os.path.isfile(os.path.join(__A				,			"""pytorch_lora_weights.bin"""       )       )       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Union[str, Any]       ):
  		__A						,							__A   : List[str]								= self.get_dummy_components()
  		__A   : Dict								= StableDiffusionPipeline(**__A       )
  		__A   : List[str]								= sd_pipe.to(__A       )
  		sd_pipe.set_progress_bar_config(disable=__A       )
  
  		__A						,							__A						,							__A   : Any								= self.get_dummy_inputs()
  
  		__A   : Optional[int]								= sd_pipe(**__A       ).images
  		__A   : str								= original_images[0, -3:, -3:, -1]
  
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			LoraLoaderMixin.save_lora_weights(
  			    save_directory=__A				,			unet_lora_layers=lora_components["""unet_lora_layers"""]				,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]				,			)
  			self.assertTrue(os.path.isfile(os.path.join(__A				,			"""pytorch_lora_weights.bin"""       )       )       )
  			sd_pipe.load_lora_weights(__A       )
  
  		__A   : str								= sd_pipe(**__A       ).images
  		__A   : Optional[int]								= lora_images[0, -3:, -3:, -1]
  
  		# Outputs shouldn't match.
  		self.assertFalse(torch.allclose(torch.from_numpy(__A       )				,			torch.from_numpy(__A       )       )       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A						,							__A   : Union[str, Any]								= self.get_dummy_components()
  		__A   : Tuple								= StableDiffusionPipeline(**__A       )
  		__A   : Any								= sd_pipe.to(__A       )
  		sd_pipe.set_progress_bar_config(disable=__A       )
  
  		__A						,							__A						,							__A   : Union[str, Any]								= self.get_dummy_inputs()
  
  		__A   : List[str]								= sd_pipe(**__A       ).images
  		__A   : Union[str, Any]								= original_images[0, -3:, -3:, -1]
  
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			LoraLoaderMixin.save_lora_weights(
  			    save_directory=__A				,			unet_lora_layers=lora_components["""unet_lora_layers"""]				,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]				,			safe_serialization=__A				,			)
  			self.assertTrue(os.path.isfile(os.path.join(__A				,			"""pytorch_lora_weights.safetensors"""       )       )       )
  			sd_pipe.load_lora_weights(__A       )
  
  		__A   : Optional[Any]								= sd_pipe(**__A       ).images
  		__A   : Tuple								= lora_images[0, -3:, -3:, -1]
  
  		# Outputs shouldn't match.
  		self.assertFalse(torch.allclose(torch.from_numpy(__A       )				,			torch.from_numpy(__A       )       )       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    int       ):
  		__A						,							__A   : int								= self.get_dummy_components()
  		__A   : Any								= lora_components["""unet_lora_attn_procs"""]
  		__A   : Optional[int]								= StableDiffusionPipeline(**__A       )
  		__A   : Tuple								= sd_pipe.to(__A       )
  		sd_pipe.set_progress_bar_config(disable=__A       )
  
  		__A						,							__A						,							__A   : Any								= self.get_dummy_inputs()
  
  		__A   : Optional[Any]								= sd_pipe(**__A       ).images
  		__A   : List[str]								= original_images[0, -3:, -3:, -1]
  
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			__A   : Optional[int]								= sd_pipe.unet
  			unet.set_attn_processor(__A       )
  			unet.save_attn_procs(__A       )
  			self.assertTrue(os.path.isfile(os.path.join(__A				,			"""pytorch_lora_weights.bin"""       )       )       )
  			sd_pipe.load_lora_weights(__A       )
  
  		__A   : Union[str, Any]								= sd_pipe(**__A       ).images
  		__A   : str								= lora_images[0, -3:, -3:, -1]
  
  		# Outputs shouldn't match.
  		self.assertFalse(torch.allclose(torch.from_numpy(__A       )				,			torch.from_numpy(__A       )       )       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A						,							__A   : List[Any]								= self.get_dummy_components()
  		__A   : Any								= StableDiffusionPipeline(**__A       )
  
  		__A   : Any								= self.get_dummy_tokens()
  
  		# inference without lora
  		__A   : List[Any]								= pipe.text_encoder(**__A       )[0]
  		assert outputs_without_lora.shape == (1, 77, 32)
  
  		# create lora_attn_procs with zeroed out up.weights
  		__A   : List[str]								= create_text_encoder_lora_attn_procs(pipe.text_encoder       )
  		set_lora_up_weights(__A				,			randn_weight=__A       )
  
  		# monkey patch
  		pipe._modify_text_encoder(__A       )
  
  		# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  		del text_attn_procs
  		gc.collect()
  
  		# inference with lora
  		__A   : Optional[Any]								= pipe.text_encoder(**__A       )[0]
  		assert outputs_with_lora.shape == (1, 77, 32)
  
  		assert torch.allclose(
  		    __A				,			__A       ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"
  
  		# create lora_attn_procs with randn up.weights
  		__A   : Optional[int]								= create_text_encoder_lora_attn_procs(pipe.text_encoder       )
  		set_lora_up_weights(__A				,			randn_weight=__A       )
  
  		# monkey patch
  		pipe._modify_text_encoder(__A       )
  
  		# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  		del text_attn_procs
  		gc.collect()
  
  		# inference with lora
  		__A   : Any								= pipe.text_encoder(**__A       )[0]
  		assert outputs_with_lora.shape == (1, 77, 32)
  
  		assert not torch.allclose(
  		    __A				,			__A       ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    str       ):
  		__A						,							__A   : Any								= self.get_dummy_components()
  		__A   : List[Any]								= StableDiffusionPipeline(**__A       )
  
  		__A   : str								= self.get_dummy_tokens()
  
  		# inference without lora
  		__A   : str								= pipe.text_encoder(**__A       )[0]
  		assert outputs_without_lora.shape == (1, 77, 32)
  
  		# create lora_attn_procs with randn up.weights
  		__A   : Tuple								= create_text_encoder_lora_attn_procs(pipe.text_encoder       )
  		set_lora_up_weights(__A				,			randn_weight=__A       )
  
  		# monkey patch
  		pipe._modify_text_encoder(__A       )
  
  		# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  		del text_attn_procs
  		gc.collect()
  
  		# inference with lora
  		__A   : Optional[int]								= pipe.text_encoder(**__A       )[0]
  		assert outputs_with_lora.shape == (1, 77, 32)
  
  		assert not torch.allclose(
  		    __A				,			__A       ), "lora outputs should be different to without lora outputs"
  
  		# remove monkey patch
  		pipe._remove_text_encoder_monkey_patch()
  
  		# inference with removed lora
  		__A   : Optional[int]								= pipe.text_encoder(**__A       )[0]
  		assert outputs_without_lora_removed.shape == (1, 77, 32)
  
  		assert torch.allclose(
  		    __A				,			__A       ), "remove lora monkey patch should restore the original outputs"
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Union[str, Any]       ):
  		__A						,							__A   : Optional[int]								= self.get_dummy_components()
  		__A   : Any								= StableDiffusionPipeline(**__A       )
  		__A   : Union[str, Any]								= sd_pipe.to(__A       )
  		sd_pipe.set_progress_bar_config(disable=__A       )
  
  		__A						,							__A						,							__A   : Any								= self.get_dummy_inputs()
  
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			LoraLoaderMixin.save_lora_weights(
  			    save_directory=__A				,			unet_lora_layers=lora_components["""unet_lora_layers"""]				,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]				,			)
  			self.assertTrue(os.path.isfile(os.path.join(__A				,			"""pytorch_lora_weights.bin"""       )       )       )
  			sd_pipe.load_lora_weights(__A       )
  
  		__A   : str								= sd_pipe(**__A       ).images
  		__A   : Tuple								= lora_images[0, -3:, -3:, -1]
  
  		__A   : List[Any]								= sd_pipe(**__A				,			cross_attention_kwargs={"""scale""": 0.5}       ).images
  		__A   : Dict								= lora_images_with_scale[0, -3:, -3:, -1]
  
  		# Outputs shouldn't match.
  		self.assertFalse(
  		    torch.allclose(torch.from_numpy(__A       )				,			torch.from_numpy(__A       )       )       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Union[str, Any]       ):
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			self.create_lora_weight_file(__A       )
  
  			__A						,							__A   : Optional[int]								= self.get_dummy_components()
  			__A   : str								= StableDiffusionPipeline(**__A       )
  			__A   : Any								= sd_pipe.to(__A       )
  			sd_pipe.set_progress_bar_config(disable=__A       )
  
  			# check if vanilla attention processors are used
  			for _, module in sd_pipe.unet.named_modules():
  				if isinstance(__A				,			__A       ):
  					self.assertIsInstance(module.processor				,			(AttnProcessor, AttnProcessor2_0)       )
  
              # load LoRA weight file
  			sd_pipe.load_lora_weights(__A       )
  
  			# check if lora attention processors are used
  			for _, module in sd_pipe.unet.named_modules():
  				if isinstance(__A				,			__A       ):
  					__A   : Tuple								= (
  					    LoRAAttnProcessor2_0 if hasattr(__A				,			"""scaled_dot_product_attention"""       ) else LoRAAttnProcessor
  					)
  					self.assertIsInstance(module.processor				,			__A       )
  
  
  
  
  	@unittest.skipIf(torch_device != """cuda"""				,			"""This test is supposed to run on GPU"""       )
  	def 					lowerCAmelCase_					(    self	:    Dict       ):
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			self.create_lora_weight_file(__A       )
  
  			__A						,							__A   : Optional[Any]								= self.get_dummy_components()
  			__A   : Any								= StableDiffusionPipeline(**__A       )
  			__A   : int								= sd_pipe.to(__A       )
  			sd_pipe.set_progress_bar_config(disable=__A       )
  
  			# enable XFormers
  			sd_pipe.enable_xformers_memory_efficient_attention()
  
  			# check if xFormers attention processors are used
  			for _, module in sd_pipe.unet.named_modules():
  				if isinstance(__A				,			__A       ):
  					self.assertIsInstance(module.processor				,			__A       )
  
              # load LoRA weight file
  			sd_pipe.load_lora_weights(__A       )
  
  			# check if lora attention processors are used
  			for _, module in sd_pipe.unet.named_modules():
  				if isinstance(__A				,			__A       ):
  					self.assertIsInstance(module.processor				,			__A       )
  
  
  
  
  	@unittest.skipIf(torch_device != """cuda"""				,			"""This test is supposed to run on GPU"""       )
  	def 					lowerCAmelCase_					(    self	:    List[Any]       ):
  		__A						,							__A   : Tuple								= self.get_dummy_components()
  		__A   : Optional[Any]								= StableDiffusionPipeline(**__A       )
  		__A   : List[str]								= sd_pipe.to(__A       )
  		sd_pipe.set_progress_bar_config(disable=__A       )
  
  		__A						,							__A						,							__A   : Any								= self.get_dummy_inputs()
  
  		# enable XFormers
  		sd_pipe.enable_xformers_memory_efficient_attention()
  
  		__A   : List[str]								= sd_pipe(**__A       ).images
  		__A   : Any								= original_images[0, -3:, -3:, -1]
  
  		with tempfile.TemporaryDirectory() as tmpdirname:
  			LoraLoaderMixin.save_lora_weights(
  			    save_directory=__A				,			unet_lora_layers=lora_components["""unet_lora_layers"""]				,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]				,			)
  			self.assertTrue(os.path.isfile(os.path.join(__A				,			"""pytorch_lora_weights.bin"""       )       )       )
  			sd_pipe.load_lora_weights(__A       )
  
  		__A   : int								= sd_pipe(**__A       ).images
  		__A   : Any								= lora_images[0, -3:, -3:, -1]
  
  		# Outputs shouldn't match.
  		self.assertFalse(torch.allclose(torch.from_numpy(__A       )				,			torch.from_numpy(__A       )       )       )
  
  
  
  
  
  
style_context: 
  
  UpperCAmelCase_       :				str		   =      [
      [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
  ]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int ,a__						:      int					)				->							bool:
  	return 0 <= row < rows and 0 <= col < cols
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      set ,a__						:      list[list[int]]					)				->							int:
  	__A   : Union[str, Any]								= len(a__					)
  	__A   : Any								= len(mat[0]					)
  	if is_safe(a__ ,a__ ,a__ ,a__					) and (row, col) not in seen and mat[row][col] == 1:
  		seen.add((row, col)					)
  		return (
  		    1
  		    + depth_first_search(row + 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(row - 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(a__ ,col + 1 ,a__ ,a__					)
  		    + depth_first_search(a__ ,col - 1 ,a__ ,a__					)
  		)
  	else:
  		return 0
  def        __SCREAMING_SNAKE_CASE    (      a__						:      list[list[int]]					)				->							int:
  	__A   : set								= set()
  
  	__A   : Union[str, Any]								= 0
  	for row, line in enumerate(a__					):
  		for col, item in enumerate(a__					):
  			if item == 1 and (row, col) not in seen:
  				# Maximizing the area
  				__A   : Optional[Any]								= max(a__ ,depth_first_search(a__ ,a__ ,a__ ,a__					)					)
  	return max_area
  
  
  if __name__ == "__main__":
  			import doctest
  
  			print(find_max_area(matrix))  # Output -> 6
  			doctest.testmod()
  
  
  
  
  
  