





"""simple docstring"""






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 			__A					(	a_  :int)						->						Optional[int]:
				__a       :  List[Any]					=     3_84
				__a       :  Tuple					=     7
				if "tiny" in model_name:
								__a       :  int					=     96
								__a       :  str					=     (2, 2, 6, 2)
								__a       :  List[Any]					=     (3, 6, 12, 24)
				elif "small" in model_name:
								__a       :  Union[str, Any]					=     96
								__a       :  Any					=     (2, 2, 18, 2)
								__a       :  Tuple					=     (3, 6, 12, 24)
				elif "base" in model_name:
								__a       :  Tuple					=     1_28
								__a       :  List[Any]					=     (2, 2, 18, 2)
								__a       :  int					=     (4, 8, 16, 32)
								__a       :  Optional[int]					=     12
								__a       :  Optional[int]					=     5_12
				elif "large" in model_name:
								__a       :  Optional[Any]					=     1_92
								__a       :  int					=     (2, 2, 18, 2)
								__a       :  int					=     (6, 12, 24, 48)
								__a       :  List[Any]					=     12
								__a       :  Optional[Any]					=     7_68

				# set label information
				__a       :  Optional[Any]					=     1_50
				__a       :  Tuple					=     """huggingface/label-files"""
				__a       :  List[str]					=     """ade20k-id2label.json"""
				__a       :  str					=     json.load(open(hf_hub_download(_snake_case      ,				_snake_case      ,				repo_type='''dataset''')      ,				'''r'''))
				__a       :  Union[str, Any]					=     {int(_snake_case): v for k, v in idalabel.items()}
				__a       :  List[Any]					=     {v: k for k, v in idalabel.items()}

				__a       :  str					=     SwinConfig(
				    embed_dim=_snake_case      ,				depths=_snake_case      ,				num_heads=_snake_case      ,				window_size=_snake_case      ,				out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']      ,				)
				__a       :  int					=     UperNetConfig(
				    backbone_config=_snake_case      ,				auxiliary_in_channels=_snake_case      ,				num_labels=_snake_case      ,				idalabel=_snake_case      ,				labelaid=_snake_case      ,				)

				return config

def 			__A					(	a_  :Dict)						->						Tuple:
				__a       :  Optional[Any]					=     []

				# 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 			__A					(	a_  :Union[str, Any]      ,				a_  :Optional[int]      ,				a_  :Dict)						->						List[Any]:
				__a       :  Optional[Any]					=     dct.pop(_snake_case)
				__a       :  Tuple					=     val

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

def 			__A					(	a_  :Tuple)						->						Union[str, Any]:
				__a       :  List[Any]					=     x.shape
				__a       :  List[Any]					=     x.reshape(_snake_case      ,				4      ,				in_channel // 4)
				__a       :  Dict					=     x[:, [0, 2, 1, 3], :].transpose(1      ,				2).reshape(_snake_case      ,				_snake_case)
				return x

def 			__A					(	a_  :Optional[int])						->						Any:
				__a       :  Optional[Any]					=     x.shape
				__a       :  Any					=     x.reshape(_snake_case      ,				in_channel // 4      ,				4)
				__a       :  Optional[Any]					=     x[:, :, [0, 2, 1, 3]].transpose(1      ,				2).reshape(_snake_case      ,				_snake_case)

				return x

def 			__A					(	a_  :Dict)						->						List[Any]:
				__a       :  Tuple					=     x.shape[0]
				__a       :  List[str]					=     x.reshape(4      ,				in_channel // 4)
				__a       :  Optional[Any]					=     x[[0, 2, 1, 3], :].transpose(0      ,				1).reshape(_snake_case)
				return x

def 			__A					(	a_  :str)						->						Union[str, Any]:
				__a       :  int					=     x.shape[0]
				__a       :  List[str]					=     x.reshape(in_channel // 4      ,				4)
				__a       :  Tuple					=     x[:, [0, 2, 1, 3]].transpose(0      ,				1).reshape(_snake_case)
				return x

def 			__A					(	a_  :Any      ,				a_  :Tuple      ,				a_  :Optional[int])						->						str:
				__a       :  List[Any]					=     {
				    """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       :  Optional[int]					=     model_name_to_url[model_name]
				__a       :  Optional[int]					=     torch.hub.load_state_dict_from_url(_snake_case      ,				map_location='''cpu'''      ,				file_name=_snake_case)[
				    """state_dict"""
				]

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

				__a       :  Optional[Any]					=     get_upernet_config(_snake_case)
				__a       :  List[str]					=     UperNetForSemanticSegmentation(_snake_case)
				model.eval()

				# replace "bn" => "batch_norm"
				for key in state_dict.copy().keys():
								__a       :  Optional[int]					=     state_dict.pop(_snake_case)
								if "bn" in key:
												__a       :  Optional[int]					=     key.replace('''bn'''      ,				'''batch_norm''')
								__a       :  Dict					=     val

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

				# fix downsample parameters
				for key, value in state_dict.items():
								if "downsample" in key:
												if "reduction" in key:
																__a       :  Union[str, Any]					=     reverse_correct_unfold_reduction_order(_snake_case)
												if "norm" in key:
																__a       :  Tuple					=     reverse_correct_unfold_norm_order(_snake_case)

				model.load_state_dict(_snake_case)

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

				__a       :  Optional[Any]					=     SegformerImageProcessor()
				__a       :  Optional[int]					=     processor(_snake_case      ,				return_tensors='''pt''').pixel_values

				with torch.no_grad():
								__a       :  Tuple					=     model(_snake_case)
								__a       :  List[Any]					=     outputs.logits

				print(logits.shape)
				print('''First values of logits:'''      ,				logits[0, 0, :3, :3])
				# assert values
				if model_name == "upernet-swin-tiny":
								__a       :  Tuple					=     torch.tensor(
								    [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]])
				elif model_name == "upernet-swin-small":
								__a       :  Optional[Any]					=     torch.tensor(
								    [[-7.1_9_2_1, -7.1_9_2_1, -6.9_5_3_2], [-7.1_9_2_1, -7.1_9_2_1, -6.9_5_3_2], [-7.0_9_0_8, -7.0_9_0_8, -6.8_5_3_4]])
				elif model_name == "upernet-swin-base":
								__a       :  Union[str, Any]					=     torch.tensor(
								    [[-6.5_8_5_1, -6.5_8_5_1, -6.4_3_3_0], [-6.5_8_5_1, -6.5_8_5_1, -6.4_3_3_0], [-6.4_7_6_3, -6.4_7_6_3, -6.3_2_5_4]])
				elif model_name == "upernet-swin-large":
								__a       :  Dict					=     torch.tensor(
								    [[-7.5_2_9_7, -7.5_2_9_7, -7.3_8_0_2], [-7.5_2_9_7, -7.5_2_9_7, -7.3_8_0_2], [-7.4_0_4_4, -7.4_0_4_4, -7.2_5_8_6]])
				print('''Logits:'''      ,				outputs.logits[0, 0, :3, :3])
				assert torch.allclose(outputs.logits[0, 0, :3, :3]      ,				_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(_snake_case)
								print(F"""Saving processor to {pytorch_dump_folder_path}""")
								processor.save_pretrained(_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__":
		A       	=     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.'''
		)

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

"""simple docstring"""




from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__      :    Optional[Any]    							= logging.get_logger(__name__)

UpperCAmelCase__      :    Dict    							= {
    'MIT/ast-finetuned-audioset-10-10-0.4593': (
        'https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json'
    ),
}



class 	lowerCAmelCase_						(a__  ):


				"""simple docstring"""



				__UpperCamelCase      :						Optional[int]					       =   '''audio-spectrogram-transformer'''



				def __init__(self   ,       SCREAMING_SNAKE_CASE__=7_68   ,       SCREAMING_SNAKE_CASE__=12   ,       SCREAMING_SNAKE_CASE__=12   ,       SCREAMING_SNAKE_CASE__=30_72   ,       SCREAMING_SNAKE_CASE__="gelu"   ,       SCREAMING_SNAKE_CASE__=0.0   ,       SCREAMING_SNAKE_CASE__=0.0   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=1E-12   ,       SCREAMING_SNAKE_CASE__=16   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=10   ,       SCREAMING_SNAKE_CASE__=10   ,       SCREAMING_SNAKE_CASE__=10_24   ,       SCREAMING_SNAKE_CASE__=1_28   ,       **SCREAMING_SNAKE_CASE__   ,       )					->		Tuple:



											"""simple docstring"""




											super().__init__(**SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   hidden_size
											SCREAMING_SNAKE_CASE__						:       str           =   num_hidden_layers
											SCREAMING_SNAKE_CASE__						:       int           =   num_attention_heads
											SCREAMING_SNAKE_CASE__						:       Tuple           =   intermediate_size
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_act
											SCREAMING_SNAKE_CASE__						:       Any           =   hidden_dropout_prob
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE__						:       int           =   initializer_range
											SCREAMING_SNAKE_CASE__						:       int           =   layer_norm_eps
											SCREAMING_SNAKE_CASE__						:       Dict           =   patch_size
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   qkv_bias
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   frequency_stride
											SCREAMING_SNAKE_CASE__						:       Any           =   time_stride
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   max_length
											SCREAMING_SNAKE_CASE__						:       Any           =   num_mel_bins




