



import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Any    ):
				"""simple docstring"""







				__a       =		384
				__a       =		7
				if "tiny" in model_name:
								__a       =		96
								__a       =		(2, 2, 6, 2)
								__a       =		(3, 6, 12, 24)
				elif "small" in model_name:
								__a       =		96
								__a       =		(2, 2, 18, 2)
								__a       =		(3, 6, 12, 24)
				elif "base" in model_name:
								__a       =		128
								__a       =		(2, 2, 18, 2)
								__a       =		(4, 8, 16, 32)
								__a       =		12
								__a       =		512
				elif "large" in model_name:
								__a       =		192
								__a       =		(2, 2, 18, 2)
								__a       =		(6, 12, 24, 48)
								__a       =		12
								__a       =		768

				# set label information
				__a       =		150
				__a       =		"""huggingface/label-files"""
				__a       =		"""ade20k-id2label.json"""
				__a       =		json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     repo_type="""dataset"""    )				,     """r"""    )    )
				__a       =		{int(_SCREAMING_SNAKE_CASE    ): v for k, v in idalabel.items()}
				__a       =		{v: k for k, v in idalabel.items()}

				__a       =		SwinConfig(
				    embed_dim=_SCREAMING_SNAKE_CASE				,     depths=_SCREAMING_SNAKE_CASE				,     num_heads=_SCREAMING_SNAKE_CASE				,     window_size=_SCREAMING_SNAKE_CASE				,     out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]				,     )
				__a       =		UperNetConfig(
				    backbone_config=_SCREAMING_SNAKE_CASE				,     auxiliary_in_channels=_SCREAMING_SNAKE_CASE				,     num_labels=_SCREAMING_SNAKE_CASE				,     idalabel=_SCREAMING_SNAKE_CASE				,     labelaid=_SCREAMING_SNAKE_CASE				,     )

				return config

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Any    ):
				"""simple docstring"""







				__a       =		[]

				# fmt: off
				# stem
				rename_keys.append(("""backbone.patch_embed.projection.weight""", """backbone.embeddings.patch_embeddings.projection.weight""")    )
				rename_keys.append(("""backbone.patch_embed.projection.bias""", """backbone.embeddings.patch_embeddings.projection.bias""")    )
				rename_keys.append(("""backbone.patch_embed.norm.weight""", """backbone.embeddings.norm.weight""")    )
				rename_keys.append(("""backbone.patch_embed.norm.bias""", """backbone.embeddings.norm.bias""")    )
				# stages
				for i in range(len(config.backbone_config.depths    )    ):
								for j in range(config.backbone_config.depths[i]    ):
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm1.weight", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm1.bias", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight", f"backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias", f"backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm2.weight", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm2.bias", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight", f"backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias", f"backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight", f"backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight")    )
												rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias", f"backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias")    )

								if i < 3:
												rename_keys.append((f"backbone.stages.{i}.downsample.reduction.weight", f"backbone.encoder.layers.{i}.downsample.reduction.weight")    )
												rename_keys.append((f"backbone.stages.{i}.downsample.norm.weight", f"backbone.encoder.layers.{i}.downsample.norm.weight")    )
												rename_keys.append((f"backbone.stages.{i}.downsample.norm.bias", f"backbone.encoder.layers.{i}.downsample.norm.bias")    )
								rename_keys.append((f"backbone.norm{i}.weight", f"backbone.hidden_states_norms.stage{i+1}.weight")    )
								rename_keys.append((f"backbone.norm{i}.bias", f"backbone.hidden_states_norms.stage{i+1}.bias")    )

				# decode head
				rename_keys.extend(
				    [
				        ("""decode_head.conv_seg.weight""", """decode_head.classifier.weight"""),
				        ("""decode_head.conv_seg.bias""", """decode_head.classifier.bias"""),
				        ("""auxiliary_head.conv_seg.weight""", """auxiliary_head.classifier.weight"""),
				        ("""auxiliary_head.conv_seg.bias""", """auxiliary_head.classifier.bias"""),
				    ]    )
				# fmt: on

				return rename_keys

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Optional[Any]				,     _SCREAMING_SNAKE_CASE       :			Any				,     _SCREAMING_SNAKE_CASE       :			Dict    ):
				"""simple docstring"""







				__a       =		dct.pop(_SCREAMING_SNAKE_CASE    )
				__a       =		val

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Dict				,     _SCREAMING_SNAKE_CASE       :			Optional[Any]    ):
				"""simple docstring"""







				__a       =		[int(backbone_config.embed_dim * 2**i    ) for i in range(len(backbone_config.depths    )    )]
				for i in range(len(backbone_config.depths    )    ):
								__a       =		num_features[i]
								for j in range(backbone_config.depths[i]    ):
												# fmt: off
												# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
												__a       =		state_dict.pop(f"backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"    )
												__a       =		state_dict.pop(f"backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias"    )
												# next, add query, keys and values (in that order) to the state dict
												__a       =		in_proj_weight[:dim, :]
												__a       =		in_proj_bias[: dim]
												__a       =		in_proj_weight[
												    dim : dim * 2, :
												]
												__a       =		in_proj_bias[
												    dim : dim * 2
												]
												__a       =		in_proj_weight[
												    -dim :, :
												]
												__a       =		in_proj_bias[-dim :]
												# fmt: on

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[Any]    ):
				"""simple docstring"""







				__a     ,					__a       =		x.shape
				__a       =		x.reshape(_SCREAMING_SNAKE_CASE				,     4				,     in_channel // 4    )
				__a       =		x[:, [0, 2, 1, 3], :].transpose(1				,     2    ).reshape(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				return x

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			int    ):
				"""simple docstring"""







				__a     ,					__a       =		x.shape
				__a       =		x.reshape(_SCREAMING_SNAKE_CASE				,     in_channel // 4				,     4    )
				__a       =		x[:, :, [0, 2, 1, 3]].transpose(1				,     2    ).reshape(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )

				return x

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str    ):
				"""simple docstring"""







				__a       =		x.shape[0]
				__a       =		x.reshape(4				,     in_channel // 4    )
				__a       =		x[[0, 2, 1, 3], :].transpose(0				,     1    ).reshape(_SCREAMING_SNAKE_CASE    )
				return x

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[Any]    ):
				"""simple docstring"""







				__a       =		x.shape[0]
				__a       =		x.reshape(in_channel // 4				,     4    )
				__a       =		x[:, [0, 2, 1, 3]].transpose(0				,     1    ).reshape(_SCREAMING_SNAKE_CASE    )
				return x

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Tuple				,     _SCREAMING_SNAKE_CASE       :			List[Any]				,     _SCREAMING_SNAKE_CASE       :			List[str]    ):
				"""simple docstring"""







				__a       =		{
				    """upernet-swin-tiny""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth""",
				    """upernet-swin-small""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth""",
				    """upernet-swin-base""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth""",
				    """upernet-swin-large""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth""",
				}
				__a       =		model_name_to_url[model_name]
				__a       =		torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE				,     map_location="""cpu"""				,     file_name=_SCREAMING_SNAKE_CASE    )[
				    """state_dict"""
				]

				for name, param in state_dict.items():
								print(_SCREAMING_SNAKE_CASE				,     param.shape    )

				__a       =		get_upernet_config(_SCREAMING_SNAKE_CASE    )
				__a       =		UperNetForSemanticSegmentation(_SCREAMING_SNAKE_CASE    )
				model.eval()

				# replace "bn" => "batch_norm"
				for key in state_dict.copy().keys():
								__a       =		state_dict.pop(_SCREAMING_SNAKE_CASE    )
								if "bn" in key:
												__a       =		key.replace("""bn"""				,     """batch_norm"""    )
								__a       =		val

				# rename keys
				__a       =		create_rename_keys(_SCREAMING_SNAKE_CASE    )
				for src, dest in rename_keys:
								rename_key(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				read_in_q_k_v(_SCREAMING_SNAKE_CASE				,     config.backbone_config    )

				# fix downsample parameters
				for key, value in state_dict.items():
								if "downsample" in key:
												if "reduction" in key:
																__a       =		reverse_correct_unfold_reduction_order(_SCREAMING_SNAKE_CASE    )
												if "norm" in key:
																__a       =		reverse_correct_unfold_norm_order(_SCREAMING_SNAKE_CASE    )

				model.load_state_dict(_SCREAMING_SNAKE_CASE    )

				# verify on image
				__a       =		"""https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"""
				__a       =		Image.open(requests.get(_SCREAMING_SNAKE_CASE				,     stream=_SCREAMING_SNAKE_CASE    ).raw    ).convert("""RGB"""    )

				__a       =		SegformerImageProcessor()
				__a       =		processor(_SCREAMING_SNAKE_CASE				,     return_tensors="""pt"""    ).pixel_values

				with torch.no_grad():
								__a       =		model(_SCREAMING_SNAKE_CASE    )
								__a       =		outputs.logits

				print(logits.shape    )
				print("""First values of logits:"""				,     logits[0, 0, :3, :3]    )
				# assert values
				if model_name == "upernet-swin-tiny":
								__a       =		torch.tensor(
								    [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]]    )
				elif model_name == "upernet-swin-small":
								__a       =		torch.tensor(
								    [[-7.1921, -7.1921, -6.9532], [-7.1921, -7.1921, -6.9532], [-7.0908, -7.0908, -6.8534]]    )
				elif model_name == "upernet-swin-base":
								__a       =		torch.tensor(
								    [[-6.5851, -6.5851, -6.4330], [-6.5851, -6.5851, -6.4330], [-6.4763, -6.4763, -6.3254]]    )
				elif model_name == "upernet-swin-large":
								__a       =		torch.tensor(
								    [[-7.5297, -7.5297, -7.3802], [-7.5297, -7.5297, -7.3802], [-7.4044, -7.4044, -7.2586]]    )
				print("""Logits:"""				,     outputs.logits[0, 0, :3, :3]    )
				assert torch.allclose(outputs.logits[0, 0, :3, :3]				,     _SCREAMING_SNAKE_CASE				,     atol=1e-4    )
				print("""Looks ok!"""    )

				if pytorch_dump_folder_path is not None:
								print(f"Saving model {model_name} to {pytorch_dump_folder_path}"    )
								model.save_pretrained(_SCREAMING_SNAKE_CASE    )
								print(f"Saving processor to {pytorch_dump_folder_path}"    )
								processor.save_pretrained(_SCREAMING_SNAKE_CASE    )

				if push_to_hub:
								print(f"Pushing model and processor for {model_name} to hub"    )
								model.push_to_hub(f"openmmlab/{model_name}"    )
								processor.push_to_hub(f"openmmlab/{model_name}"    )


if __name__ == "__main__":
						lowerCamelCase__			= argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    """--model_name""",
						    default="""upernet-swin-tiny""",
						    type=str,
						    choices=[F"""upernet-swin-{size}""" for size in ["""tiny""", """small""", """base""", """large"""]],
						    help="""Name of the Swin + UperNet model you'd like to convert.""",
						)
						parser.add_argument(
						    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
						)
						parser.add_argument(
						    """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
						)

						lowerCamelCase__			= parser.parse_args()
						convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





import os

def   lowerCAmelCase__						(							):
				"""simple docstring"""







				__a       =		os.path.dirname(os.path.realpath(_SCREAMING_SNAKE_CASE    )    )
				__a       =		os.path.join(_SCREAMING_SNAKE_CASE				,     """triangle.txt"""    )

				with open(_SCREAMING_SNAKE_CASE    ) as f:
								__a       =		f.readlines()

				__a       =		[]
				for line in triangle:
								__a       =		[]
								for number in line.strip().split(""" """    ):
												numbers_from_line.append(int(_SCREAMING_SNAKE_CASE    )    )
								a.append(_SCREAMING_SNAKE_CASE    )

				for i in range(1				,     len(_SCREAMING_SNAKE_CASE    )    ):
								for j in range(len(a[i]    )    ):
												__a       =		a[i - 1][j] if j != len(a[i - 1]    ) else 0
												__a       =		a[i - 1][j - 1] if j > 0 else 0
												a[i][j] += max(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				return max(a[-1]    )


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