



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  UpperCAmelCase__    (    lowercase__   ) ->      Union[str, Any]:
						__lowercase					=				384
						__lowercase					=				7
						if "tiny" in model_name:
												__lowercase					=				96
												__lowercase					=				(2, 2, 6, 2)
												__lowercase					=				(3, 6, 12, 24)
						elif "small" in model_name:
												__lowercase					=				96
												__lowercase					=				(2, 2, 18, 2)
												__lowercase					=				(3, 6, 12, 24)
						elif "base" in model_name:
												__lowercase					=				128
												__lowercase					=				(2, 2, 18, 2)
												__lowercase					=				(4, 8, 16, 32)
												__lowercase					=				12
												__lowercase					=				512
						elif "large" in model_name:
												__lowercase					=				192
												__lowercase					=				(2, 2, 18, 2)
												__lowercase					=				(6, 12, 24, 48)
												__lowercase					=				12
												__lowercase					=				768

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

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

						return config






def  UpperCAmelCase__    (    lowercase__   ) ->      str:
						__lowercase					=				[]

						# 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  UpperCAmelCase__    (    lowercase__						,       lowercase__						,       lowercase__   ) ->      Union[str, Any]:
						__lowercase					=				dct.pop(lowercase__   )
						__lowercase					=				val






def  UpperCAmelCase__    (    lowercase__						,       lowercase__   ) ->      Tuple:
						__lowercase					=				[int(backbone_config.embed_dim * 2**i   ) for i in range(len(backbone_config.depths   )   )]
						for i in range(len(backbone_config.depths   )   ):
												__lowercase					=				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)
																		__lowercase					=				state_dict.pop(F"backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"   )
																		__lowercase					=				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
																		__lowercase					=				in_proj_weight[:dim, :]
																		__lowercase					=				in_proj_bias[: dim]
																		__lowercase					=				in_proj_weight[
																		    dim : dim * 2, :
																		]
																		__lowercase					=				in_proj_bias[
																		    dim : dim * 2
																		]
																		__lowercase					=				in_proj_weight[
																		    -dim :, :
																		]
																		__lowercase					=				in_proj_bias[-dim :]
																		# fmt: on






def  UpperCAmelCase__    (    lowercase__   ) ->      Tuple:
						__lowercase	,			__lowercase					=				x.shape
						__lowercase					=				x.reshape(lowercase__						,       4						,       in_channel // 4   )
						__lowercase					=				x[:, [0, 2, 1, 3], :].transpose(1						,       2   ).reshape(lowercase__						,       lowercase__   )
						return x






def  UpperCAmelCase__    (    lowercase__   ) ->      int:
						__lowercase	,			__lowercase					=				x.shape
						__lowercase					=				x.reshape(lowercase__						,       in_channel // 4						,       4   )
						__lowercase					=				x[:, :, [0, 2, 1, 3]].transpose(1						,       2   ).reshape(lowercase__						,       lowercase__   )

						return x






def  UpperCAmelCase__    (    lowercase__   ) ->      List[Any]:
						__lowercase					=				x.shape[0]
						__lowercase					=				x.reshape(4						,       in_channel // 4   )
						__lowercase					=				x[[0, 2, 1, 3], :].transpose(0						,       1   ).reshape(lowercase__   )
						return x






def  UpperCAmelCase__    (    lowercase__   ) ->      List[str]:
						__lowercase					=				x.shape[0]
						__lowercase					=				x.reshape(in_channel // 4						,       4   )
						__lowercase					=				x[:, [0, 2, 1, 3]].transpose(0						,       1   ).reshape(lowercase__   )
						return x






def  UpperCAmelCase__    (    lowercase__						,       lowercase__						,       lowercase__   ) ->      int:
						__lowercase					=				{
						    """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""",
						}
						__lowercase					=				model_name_to_url[model_name]
						__lowercase					=				torch.hub.load_state_dict_from_url(lowercase__						,       map_location="""cpu"""						,       file_name=lowercase__   )[
						    """state_dict"""
						]

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

						__lowercase					=				get_upernet_config(lowercase__   )
						__lowercase					=				UperNetForSemanticSegmentation(lowercase__   )
						model.eval()

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

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

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

						model.load_state_dict(lowercase__   )

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

						__lowercase					=				SegformerImageProcessor()
						__lowercase					=				processor(lowercase__						,       return_tensors="""pt"""   ).pixel_values

						with torch.no_grad():
												__lowercase					=				model(lowercase__   )
												__lowercase					=				outputs.logits

						print(logits.shape   )
						print("""First values of logits:"""						,       logits[0, 0, :3, :3]   )
						# assert values
						if model_name == "upernet-swin-tiny":
												__lowercase					=				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":
												__lowercase					=				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":
												__lowercase					=				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":
												__lowercase					=				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]						,       lowercase__						,       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(lowercase__   )
												print(F"Saving processor to {pytorch_dump_folder_path}"   )
												processor.save_pretrained(lowercase__   )

						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__":
			UpperCamelCase__ =						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."
			)

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










import importlib
import os
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, Optional, Union

import torch

from ..utils import BaseOutput


UpperCamelCase__ =						"scheduler_config.json"
class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  List[Any]      =			1
			lowercase__      :  Tuple      =			2
			lowercase__      :  Union[str, Any]      =			3
			lowercase__      :  Union[str, Any]      =			4
			lowercase__      :  str      =			5
			lowercase__      :  Any      =			6
			lowercase__      :  Any      =			7
			lowercase__      :  List[str]      =			8
			lowercase__      :  Union[str, Any]      =			9
			lowercase__      :  int      =			10
			lowercase__      :  List[str]      =			11
			lowercase__      :  List[Any]      =			12
			lowercase__      :  str      =			13
			lowercase__      :  Optional[int]      =			14





@dataclass
class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  torch.FloatTensor





class 			_lowerCAmelCase   :






			"""simple docstring"""





			lowercase__      :  Optional[int]      =			SCHEDULER_CONFIG_NAME
			lowercase__      :  int      =			[]
			lowercase__      :  Dict      =			True





			@classmethod
			def 		snake_case__			(				cls	:       str			,     lowercase	:       Dict[str, Any] = None			,     lowercase	:       Optional[str] = None			,     lowercase	:       Any=False			,     **lowercase	:       List[str]			,     )						->					Union[str, Any]:
									"""simple docstring"""







									__lowercase	,			__lowercase	,			__lowercase					=				cls.load_config(
									    pretrained_model_name_or_path=lowercase			,     subfolder=lowercase			,     return_unused_kwargs=lowercase			,     return_commit_hash=lowercase			,     **lowercase			,     )
									return cls.from_config(lowercase			,     return_unused_kwargs=lowercase			,     **lowercase   )





			def 		snake_case__			(				self	:       Dict			,     lowercase	:       Union[str, os.PathLike]			,     lowercase	:       bool = False			,     **lowercase	:       List[str]   )						->					Optional[Any]:
									"""simple docstring"""







									self.save_config(save_directory=lowercase			,     push_to_hub=lowercase			,     **lowercase   )





			@property
			def 		snake_case__			(				self	:       Optional[Any]   )						->					Dict:
									"""simple docstring"""







									return self._get_compatibles()







			@classmethod
			def 		snake_case__			(				cls	:       List[str]   )						->					Union[str, Any]:
									"""simple docstring"""







									__lowercase					=				list(set([cls.__name__] + cls._compatibles   )   )
									__lowercase					=				importlib.import_module(__name__.split("""."""   )[0]   )
									__lowercase					=				[
									    getattr(lowercase			,     lowercase   ) for c in compatible_classes_str if hasattr(lowercase			,     lowercase   )
									]
									return compatible_classes





