


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  (				SCREAMING_SNAKE_CASE	:				Any     ):







 """simple docstring"""



 UpperCamelCase__					:    Optional[int]          =   384
 UpperCamelCase__					:    int          =   7
 if "tiny" in model_name:
  UpperCamelCase__					:    Dict          =   96
  UpperCamelCase__					:    int          =   (2, 2, 6, 2)
  UpperCamelCase__					:    List[str]          =   (3, 6, 12, 24)
 elif "small" in model_name:
  UpperCamelCase__					:    Optional[int]          =   96
  UpperCamelCase__					:    Union[str, Any]          =   (2, 2, 18, 2)
  UpperCamelCase__					:    Tuple          =   (3, 6, 12, 24)
 elif "base" in model_name:
  UpperCamelCase__					:    Any          =   128
  UpperCamelCase__					:    int          =   (2, 2, 18, 2)
  UpperCamelCase__					:    str          =   (4, 8, 16, 32)
  UpperCamelCase__					:    List[str]          =   12
  UpperCamelCase__					:    List[Any]          =   512
 elif "large" in model_name:
  UpperCamelCase__					:    Tuple          =   192
  UpperCamelCase__					:    Optional[Any]          =   (2, 2, 18, 2)
  UpperCamelCase__					:    Tuple          =   (6, 12, 24, 48)
  UpperCamelCase__					:    Tuple          =   12
  UpperCamelCase__					:    Optional[int]          =   768

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

 UpperCamelCase__					:    Dict          =   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''']    , )
 UpperCamelCase__					:    Dict          =   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 			_a  (				SCREAMING_SNAKE_CASE	:				int     ):







 """simple docstring"""



 UpperCamelCase__					:    Optional[int]          =   []

 # 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  (				SCREAMING_SNAKE_CASE	:				List[Any]    , SCREAMING_SNAKE_CASE	:				Any    , SCREAMING_SNAKE_CASE	:				Dict     ):







 """simple docstring"""



 UpperCamelCase__					:    List[str]          =   dct.pop(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Tuple          =   val

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[Any]    , SCREAMING_SNAKE_CASE	:				str     ):







 """simple docstring"""



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

def 			_a  (				SCREAMING_SNAKE_CASE	:				Optional[int]     ):







 """simple docstring"""



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

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[str]     ):







 """simple docstring"""



 UpperCamelCase__					:    Union[str, Any]          =   x.shape
 UpperCamelCase__					:    List[Any]          =   x.reshape(SCREAMING_SNAKE_CASE    , in_channel // 4    , 4     )
 UpperCamelCase__					:    List[str]          =   x[:, :, [0, 2, 1, 3]].transpose(1    , 2     ).reshape(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )

 return x

def 			_a  (				SCREAMING_SNAKE_CASE	:				int     ):







 """simple docstring"""



 UpperCamelCase__					:    int          =   x.shape[0]
 UpperCamelCase__					:    List[Any]          =   x.reshape(4    , in_channel // 4     )
 UpperCamelCase__					:    Tuple          =   x[[0, 2, 1, 3], :].transpose(0    , 1     ).reshape(SCREAMING_SNAKE_CASE     )
 return x

def 			_a  (				SCREAMING_SNAKE_CASE	:				Optional[Any]     ):







 """simple docstring"""



 UpperCamelCase__					:    Tuple          =   x.shape[0]
 UpperCamelCase__					:    int          =   x.reshape(in_channel // 4    , 4     )
 UpperCamelCase__					:    Optional[int]          =   x[:, [0, 2, 1, 3]].transpose(0    , 1     ).reshape(SCREAMING_SNAKE_CASE     )
 return x

def 			_a  (				SCREAMING_SNAKE_CASE	:				Any    , SCREAMING_SNAKE_CASE	:				int    , SCREAMING_SNAKE_CASE	:				Any     ):







 """simple docstring"""



 UpperCamelCase__					:    Optional[int]          =   {
     '''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''',
 }
 UpperCamelCase__					:    Any          =   model_name_to_url[model_name]
 UpperCamelCase__					:    List[Any]          =   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     )

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

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

 # rename keys
 UpperCamelCase__					:    str          =   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:
    UpperCamelCase__					:    int          =   reverse_correct_unfold_reduction_order(SCREAMING_SNAKE_CASE     )
   if "norm" in key:
    UpperCamelCase__					:    Union[str, Any]          =   reverse_correct_unfold_norm_order(SCREAMING_SNAKE_CASE     )

 model.load_state_dict(SCREAMING_SNAKE_CASE     )

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

 UpperCamelCase__					:    Tuple          =   SegformerImageProcessor()
 UpperCamelCase__					:    int          =   processor(SCREAMING_SNAKE_CASE    , return_tensors='''pt'''     ).pixel_values

 with torch.no_grad():
  UpperCamelCase__					:    List[Any]          =   model(SCREAMING_SNAKE_CASE     )
  UpperCamelCase__					:    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":
  UpperCamelCase__					:    Tuple          =   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":
  UpperCamelCase__					:    int          =   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":
  UpperCamelCase__					:    Optional[Any]          =   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":
  UpperCamelCase__					:    List[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]    , 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__":
       __UpperCamelCase       :       str						       =				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       :       str						       =				parser.parse_args()
       convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






from math import factorial, radians

def 			_a  (				SCREAMING_SNAKE_CASE	:				float    , SCREAMING_SNAKE_CASE	:				int = 18    , SCREAMING_SNAKE_CASE	:				int = 10     ):







 """simple docstring"""



 UpperCamelCase__					:    Dict          =   angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0)

 # Converting from degrees to radians
 UpperCamelCase__					:    int          =   radians(SCREAMING_SNAKE_CASE     )

 UpperCamelCase__					:    Tuple          =   angle_in_radians
 UpperCamelCase__					:    str          =   3
 UpperCamelCase__					:    int          =   -1

 for _ in range(SCREAMING_SNAKE_CASE     ):
  result += (b * (angle_in_radians**a)) / factorial(SCREAMING_SNAKE_CASE     )

  UpperCamelCase__					:    List[Any]          =   -b  # One positive term and the next will be negative and so on...
  a += 2  # Increased by 2 for every term.

 return round(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )


if __name__ == "__main__":
       __import__("doctest").testmod()


