

from __future__ import annotations

import math
import random
from typing import Any






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(			self							: Union[str, Any]	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      list[Any]				     =       []
				SCREAMING_SNAKE_CASE   :      int				     =       0
				SCREAMING_SNAKE_CASE   :      int				     =       0
			def 							__UpperCamelCase (			self							: List[Any]	)							->       bool:

				"""simple docstring"""

				return self.head == self.tail
			def 							__UpperCamelCase (			self							: Optional[int]      ,      a							: Any	)							->       None:

				"""simple docstring"""

				self.data.append(a	)
				SCREAMING_SNAKE_CASE   :      List[str]				     =       self.tail + 1
			def 							__UpperCamelCase (			self							: Tuple	)							->       Any:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       self.data[self.head]
				SCREAMING_SNAKE_CASE   :      List[str]				     =       self.head + 1
				return ret
			def 							__UpperCamelCase (			self							: List[str]	)							->       int:

				"""simple docstring"""

				return self.tail - self.head






			def 							__UpperCamelCase (			self							: Optional[Any]	)							->       None:

				"""simple docstring"""

				print(self.data	)
				print("**************"	)
				print(self.data[self.head : self.tail]	)






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(			self							: List[str]      ,      a							: Any	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Dict				     =       data
				SCREAMING_SNAKE_CASE   :      MyNode | None				     =       None
				SCREAMING_SNAKE_CASE   :      MyNode | None				     =       None
				SCREAMING_SNAKE_CASE   :      int				     =       1
			def 							__UpperCamelCase (			self							: Tuple	)							->       Any:

				"""simple docstring"""

				return self.data
			def 							__UpperCamelCase (			self							: Optional[int]	)							->       MyNode | None:

				"""simple docstring"""

				return self.left
			def 							__UpperCamelCase (			self							: Union[str, Any]	)							->       MyNode | None:

				"""simple docstring"""

				return self.right
			def 							__UpperCamelCase (			self							: Union[str, Any]	)							->       int:

				"""simple docstring"""

				return self.height
			def 							__UpperCamelCase (			self							: Union[str, Any]      ,      a							: Any	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       data
			def 							__UpperCamelCase (			self							: Any      ,      a							: MyNode | None	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       node
			def 							__UpperCamelCase (			self							: List[str]      ,      a							: MyNode | None	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Any				     =       node






			def 							__UpperCamelCase (			self							: Optional[int]      ,      a							: int	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       height

def  lowerCamelCase__ (					_a):
	if node is None:
		return 0
	return node.get_height()

def  lowerCamelCase__ (					_a							,			_a):
	if a > b:
		return a
	return b

def  lowerCamelCase__ (					_a):
	print("left rotation node:"							,			node.get_data())
	SCREAMING_SNAKE_CASE   :      List[str]				     =       node.get_left()
	assert ret is not None
	node.set_left(ret.get_right())
	ret.set_right(_a)
	SCREAMING_SNAKE_CASE   :      List[Any]				     =       my_max(get_height(node.get_right())							,			get_height(node.get_left())) + 1
	node.set_height(_a)
	SCREAMING_SNAKE_CASE   :      Optional[int]				     =       my_max(get_height(ret.get_right())							,			get_height(ret.get_left())) + 1
	ret.set_height(_a)
	return ret

def  lowerCamelCase__ (					_a):
	print("right rotation node:"							,			node.get_data())
	SCREAMING_SNAKE_CASE   :      Dict				     =       node.get_right()
	assert ret is not None
	node.set_right(ret.get_left())
	ret.set_left(_a)
	SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       my_max(get_height(node.get_right())							,			get_height(node.get_left())) + 1
	node.set_height(_a)
	SCREAMING_SNAKE_CASE   :      Tuple				     =       my_max(get_height(ret.get_right())							,			get_height(ret.get_left())) + 1
	ret.set_height(_a)
	return ret

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE   :      List[Any]				     =       node.get_left()
	assert left_child is not None
	node.set_left(left_rotation(_a))
	return right_rotation(_a)

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE   :      int				     =       node.get_right()
	assert right_child is not None
	node.set_right(right_rotation(_a))
	return left_rotation(_a)

def  lowerCamelCase__ (					_a							,			_a):
	if node is None:
		return MyNode(_a)
	if data < node.get_data():
		node.set_left(insert_node(node.get_left()							,			_a))
		if (
		    get_height(node.get_left()) - get_height(node.get_right()) == 2
		):  # an unbalance detected
			SCREAMING_SNAKE_CASE   :      List[Any]				     =       node.get_left()
			assert left_child is not None
			if (
			    data < left_child.get_data()
			):  # new node is the left child of the left child
				SCREAMING_SNAKE_CASE   :      Tuple				     =       right_rotation(_a)
			else:
				SCREAMING_SNAKE_CASE   :      int				     =       lr_rotation(_a)
	else:
		node.set_right(insert_node(node.get_right()							,			_a))
		if get_height(node.get_right()) - get_height(node.get_left()) == 2:
			SCREAMING_SNAKE_CASE   :      Any				     =       node.get_right()
			assert right_child is not None
			if data < right_child.get_data():
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       rl_rotation(_a)
			else:
				SCREAMING_SNAKE_CASE   :      int				     =       left_rotation(_a)
	SCREAMING_SNAKE_CASE   :      str				     =       my_max(get_height(node.get_right())							,			get_height(node.get_left())) + 1
	node.set_height(_a)
	return node

def  lowerCamelCase__ (					_a):
	while True:
		SCREAMING_SNAKE_CASE   :      List[Any]				     =       root.get_right()
		if right_child is None:
			break
		SCREAMING_SNAKE_CASE   :      str				     =       right_child
	return root.get_data()

def  lowerCamelCase__ (					_a):
	while True:
		SCREAMING_SNAKE_CASE   :      Optional[int]				     =       root.get_left()
		if left_child is None:
			break
		SCREAMING_SNAKE_CASE   :      List[str]				     =       left_child
	return root.get_data()

def  lowerCamelCase__ (					_a							,			_a):
	SCREAMING_SNAKE_CASE   :      Any				     =       root.get_left()
	SCREAMING_SNAKE_CASE   :      List[Any]				     =       root.get_right()
	if root.get_data() == data:
		if left_child is not None and right_child is not None:
			SCREAMING_SNAKE_CASE   :      Any				     =       get_left_most(_a)
			root.set_data(_a)
			root.set_right(del_node(_a							,			_a))
		elif left_child is not None:
			SCREAMING_SNAKE_CASE   :      Dict				     =       left_child
		elif right_child is not None:
			SCREAMING_SNAKE_CASE   :      str				     =       right_child
		else:
			return None
	elif root.get_data() > data:
		if left_child is None:
			print("No such data")
			return root
		else:
			root.set_left(del_node(_a							,			_a))
	else:  # root.get_data() < data
		if right_child is None:
			return root
		else:
			root.set_right(del_node(_a							,			_a))

	if get_height(_a) - get_height(_a) == 2:
		assert right_child is not None
		if get_height(right_child.get_right()) > get_height(right_child.get_left()):
			SCREAMING_SNAKE_CASE   :      List[str]				     =       left_rotation(_a)
		else:
			SCREAMING_SNAKE_CASE   :      int				     =       rl_rotation(_a)
	elif get_height(_a) - get_height(_a) == -2:
		assert left_child is not None
		if get_height(left_child.get_left()) > get_height(left_child.get_right()):
			SCREAMING_SNAKE_CASE   :      str				     =       right_rotation(_a)
		else:
			SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       lr_rotation(_a)
	SCREAMING_SNAKE_CASE   :      List[str]				     =       my_max(get_height(root.get_right())							,			get_height(root.get_left())) + 1
	root.set_height(_a)
	return root






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(			self							: str	)							->       None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      MyNode | None				     =       None
			def 							__UpperCamelCase (			self							: Any	)							->       int:

				"""simple docstring"""

				return get_height(self.root	)
			def 							__UpperCamelCase (			self							: List[Any]      ,      a							: Any	)							->       None:

				"""simple docstring"""

				print("insert:" + str(a	)	)
				SCREAMING_SNAKE_CASE   :      Any				     =       insert_node(self.root      ,      a	)
			def 							__UpperCamelCase (			self							: List[Any]      ,      a							: Any	)							->       None:

				"""simple docstring"""

				print("delete:" + str(a	)	)
				if self.root is None:
					print("Tree is empty!"	)
					return
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       del_node(self.root      ,      a	)






			def __str__(			self							: Optional[int]      ,      )							->       str:  # a level traversale, gives a more intuitive look on the tree

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Tuple				     =       ""
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       MyQueue()
				q.push(self.root	)
				SCREAMING_SNAKE_CASE   :      Any				     =       self.get_height()
				if layer == 0:
					return output
				SCREAMING_SNAKE_CASE   :      Dict				     =       0
				while not q.is_empty():
					SCREAMING_SNAKE_CASE   :      Dict				     =       q.pop()
					SCREAMING_SNAKE_CASE   :      List[Any]				     =       " " * int(math.pow(2      ,      layer - 1	)	)
					output += space
					if node is None:
						output += "*"
						q.push(a	)
						q.push(a	)
					else:
						output += str(node.get_data()	)
						q.push(node.get_left()	)
						q.push(node.get_right()	)
					output += space
					SCREAMING_SNAKE_CASE   :      List[str]				     =       cnt + 1
					for i in range(100	):
						if cnt == math.pow(2      ,      a	) - 1:
							SCREAMING_SNAKE_CASE   :      List[str]				     =       layer - 1
							if layer == 0:
								output += "\n*************************************"
								return output
							output += "\n"
							break
				output += "\n*************************************"
				return output

def  lowerCamelCase__ (					):
	import doctest

	doctest.testmod()


if __name__ == "__main__":
			_test()
			a_						     =    AVLtree()
			a_						     =    list(range(10))
			random.shuffle(lst)
			for i in lst:
						t.insert(i)
						print(str(t))
			random.shuffle(lst)
			for i in lst:
						t.del_node(i)
						print(str(t))


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

	# set label information
	SCREAMING_SNAKE_CASE   :      Optional[int]				     =       150
	SCREAMING_SNAKE_CASE   :      int				     =       "huggingface/label-files"
	SCREAMING_SNAKE_CASE   :      Dict				     =       "ade20k-id2label.json"
	SCREAMING_SNAKE_CASE   :      List[Any]				     =       json.load(open(hf_hub_download(_a							,			_a							,			repo_type="dataset")							,			"r"))
	SCREAMING_SNAKE_CASE   :      List[Any]				     =       {int(_a): v for k, v in idalabel.items()}
	SCREAMING_SNAKE_CASE   :      int				     =       {v: k for k, v in idalabel.items()}

	SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       SwinConfig(
	    embed_dim=_a							,			depths=_a							,			num_heads=_a							,			window_size=_a							,			out_features=["stage1", "stage2", "stage3", "stage4"]							,			)
	SCREAMING_SNAKE_CASE   :      List[str]				     =       UperNetConfig(
	    backbone_config=_a							,			auxiliary_in_channels=_a							,			num_labels=_a							,			idalabel=_a							,			labelaid=_a							,			)

	return config

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE   :      List[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  lowerCamelCase__ (					_a							,			_a							,			_a):
	SCREAMING_SNAKE_CASE   :      Any				     =       dct.pop(_a)
	SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       val

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

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      List[Any]				     =       x.shape
	SCREAMING_SNAKE_CASE   :      List[str]				     =       x.reshape(_a							,			4							,			in_channel // 4)
	SCREAMING_SNAKE_CASE   :      str				     =       x[:, [0, 2, 1, 3], :].transpose(1							,			2).reshape(_a							,			_a)
	return x

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      Any				     =       x.shape
	SCREAMING_SNAKE_CASE   :      Tuple				     =       x.reshape(_a							,			in_channel // 4							,			4)
	SCREAMING_SNAKE_CASE   :      Optional[int]				     =       x[:, :, [0, 2, 1, 3]].transpose(1							,			2).reshape(_a							,			_a)

	return x

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE   :      str				     =       x.shape[0]
	SCREAMING_SNAKE_CASE   :      int				     =       x.reshape(4							,			in_channel // 4)
	SCREAMING_SNAKE_CASE   :      int				     =       x[[0, 2, 1, 3], :].transpose(0							,			1).reshape(_a)
	return x

def  lowerCamelCase__ (					_a):
	SCREAMING_SNAKE_CASE   :      Any				     =       x.shape[0]
	SCREAMING_SNAKE_CASE   :      Dict				     =       x.reshape(in_channel // 4							,			4)
	SCREAMING_SNAKE_CASE   :      Dict				     =       x[:, [0, 2, 1, 3]].transpose(0							,			1).reshape(_a)
	return x

def  lowerCamelCase__ (					_a							,			_a							,			_a):
	SCREAMING_SNAKE_CASE   :      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",
	}
	SCREAMING_SNAKE_CASE   :      Optional[int]				     =       model_name_to_url[model_name]
	SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       torch.hub.load_state_dict_from_url(_a							,			map_location="cpu"							,			file_name=_a)[
	    "state_dict"
	]

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

	SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       get_upernet_config(_a)
	SCREAMING_SNAKE_CASE   :      Dict				     =       UperNetForSemanticSegmentation(_a)
	model.eval()

	# replace "bn" => "batch_norm"
	for key in state_dict.copy().keys():
		SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       state_dict.pop(_a)
		if "bn" in key:
			SCREAMING_SNAKE_CASE   :      Any				     =       key.replace("bn"							,			"batch_norm")
		SCREAMING_SNAKE_CASE   :      List[Any]				     =       val

	# rename keys
	SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       create_rename_keys(_a)
	for src, dest in rename_keys:
		rename_key(_a							,			_a							,			_a)
	read_in_q_k_v(_a							,			config.backbone_config)

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

	model.load_state_dict(_a)

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

	SCREAMING_SNAKE_CASE   :      Tuple				     =       SegformerImageProcessor()
	SCREAMING_SNAKE_CASE   :      Dict				     =       processor(_a							,			return_tensors="pt").pixel_values

	with torch.no_grad():
		SCREAMING_SNAKE_CASE   :      str				     =       model(_a)
		SCREAMING_SNAKE_CASE   :      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":
		SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       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":
		SCREAMING_SNAKE_CASE   :      Tuple				     =       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":
		SCREAMING_SNAKE_CASE   :      str				     =       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":
		SCREAMING_SNAKE_CASE   :      Any				     =       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]							,			_a							,			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(_a)
		print(f"Saving processor to {pytorch_dump_folder_path}")
		processor.save_pretrained(_a)

	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)