
'''simple docstring'''



import argparse

import torch
from safetensors.torch import load_file

from diffusers import StableDiffusionPipeline


def A				(__lowerCamelCase				:Union[str, Any]			,     __lowerCamelCase				:Tuple			,     __lowerCamelCase				:str			,     __lowerCamelCase				:str			,     __lowerCamelCase				:List[Any]		):
						# load base model
						_lowerCAmelCase  						=			StableDiffusionPipeline.from_pretrained(lowerCamelCase__			,     torch_dtype=torch.floataa		)

						# load LoRA weight from .safetensors
						_lowerCAmelCase  						=			load_file(lowerCamelCase__		)

						_lowerCAmelCase  						=			[]

						# directly update weight in diffusers model
						for key in state_dict:
												# it is suggested to print out the key, it usually will be something like below
												# "lora_te_text_model_encoder_layers_0_self_attn_k_proj.lora_down.weight"

												# as we have set the alpha beforehand, so just skip
												if ".alpha" in key or key in visited:
																		continue

												if "text" in key:
																		_lowerCAmelCase  						=			key.split("""."""		)[0].split(LORA_PREFIX_TEXT_ENCODER + """_"""		)[-1].split("""_"""		)
																		_lowerCAmelCase  						=			pipeline.text_encoder
												else:
																		_lowerCAmelCase  						=			key.split("""."""		)[0].split(LORA_PREFIX_UNET + """_"""		)[-1].split("""_"""		)
																		_lowerCAmelCase  						=			pipeline.unet

												# find the target layer
												_lowerCAmelCase  						=			layer_infos.pop(0		)
												while len(lowerCamelCase__		) > -1:
																		try:
																								_lowerCAmelCase  						=			curr_layer.__getattr__(lowerCamelCase__		)
																								if len(lowerCamelCase__		) > 0:
																														_lowerCAmelCase  						=			layer_infos.pop(0		)
																								elif len(lowerCamelCase__		) == 0:
																														break
																		except Exception:
																								if len(lowerCamelCase__		) > 0:
																														temp_name += "_" + layer_infos.pop(0		)
																								else:
																														_lowerCAmelCase  						=			layer_infos.pop(0		)

												_lowerCAmelCase  						=			[]
												if "lora_down" in key:
																		pair_keys.append(key.replace("""lora_down"""			,     """lora_up"""		)		)
																		pair_keys.append(lowerCamelCase__		)
												else:
																		pair_keys.append(lowerCamelCase__		)
																		pair_keys.append(key.replace("""lora_up"""			,     """lora_down"""		)		)

												# update weight
												if len(state_dict[pair_keys[0]].shape		) == 4:
																		_lowerCAmelCase  						=			state_dict[pair_keys[0]].squeeze(3		).squeeze(2		).to(torch.floataa		)
																		_lowerCAmelCase  						=			state_dict[pair_keys[1]].squeeze(3		).squeeze(2		).to(torch.floataa		)
																		curr_layer.weight.data += alpha * torch.mm(lowerCamelCase__			,     lowerCamelCase__		).unsqueeze(2		).unsqueeze(3		)
												else:
																		_lowerCAmelCase  						=			state_dict[pair_keys[0]].to(torch.floataa		)
																		_lowerCAmelCase  						=			state_dict[pair_keys[1]].to(torch.floataa		)
																		curr_layer.weight.data += alpha * torch.mm(lowerCamelCase__			,     lowerCamelCase__		)

												# update visited list
												for item in pair_keys:
																		visited.append(lowerCamelCase__		)

						return pipeline


if __name__ == "__main__":
						_lowercase    =		argparse.ArgumentParser()

						parser.add_argument(
						    """--base_model_path""", default=None, type=str, required=True, help="""Path to the base model in diffusers format."""
						)
						parser.add_argument(
						    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
						)
						parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
						parser.add_argument(
						    """--lora_prefix_unet""", default="""lora_unet""", type=str, help="""The prefix of UNet weight in safetensors"""
						)
						parser.add_argument(
						    """--lora_prefix_text_encoder""",
						    default="""lora_te""",
						    type=str,
						    help="""The prefix of text encoder weight in safetensors""",
						)
						parser.add_argument("""--alpha""", default=0.75, type=float, help="""The merging ratio in W = W0 + alpha * deltaW""")
						parser.add_argument(
						    """--to_safetensors""", action="""store_true""", help="""Whether to store pipeline in safetensors format or not."""
						)
						parser.add_argument("""--device""", type=str, help="""Device to use (e.g. cpu, cuda:0, cuda:1, etc.)""")

						_lowercase    =		parser.parse_args()

						_lowercase    =		args.base_model_path
						_lowercase    =		args.checkpoint_path
						_lowercase    =		args.dump_path
						_lowercase    =		args.lora_prefix_unet
						_lowercase    =		args.lora_prefix_text_encoder
						_lowercase    =		args.alpha

						_lowercase    =		convert(base_model_path, checkpoint_path, lora_prefix_unet, lora_prefix_text_encoder, alpha)

						_lowercase    =		pipe.to(args.device)
						pipe.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)


'''simple docstring'''



import os


def A				():
						with open(os.path.dirname(__lowerCamelCase		) + """/grid.txt"""		) as f:
												_lowerCAmelCase  						=			[]  # noqa: E741
												for _ in range(20		):
																		l.append([int(__lowerCamelCase		) for x in f.readline().split()]		)

												_lowerCAmelCase  						=			0

												# right
												for i in range(20		):
																		for j in range(17		):
																								_lowerCAmelCase  						=			l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
																								if temp > maximum:
																														_lowerCAmelCase  						=			temp

        # down
												for i in range(17		):
																		for j in range(20		):
																								_lowerCAmelCase  						=			l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
																								if temp > maximum:
																														_lowerCAmelCase  						=			temp

        # diagonal 1
												for i in range(17		):
																		for j in range(17		):
																								_lowerCAmelCase  						=			l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
																								if temp > maximum:
																														_lowerCAmelCase  						=			temp

        # diagonal 2
												for i in range(17		):
																		for j in range(3			,     20		):
																								_lowerCAmelCase  						=			l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
																								if temp > maximum:
																														_lowerCAmelCase  						=			temp
												return maximum


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