
'''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    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     List[str]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				3_84
   _SCREAMING_SNAKE_CASE      =				7
   if "tiny" in model_name:
      _SCREAMING_SNAKE_CASE      =				96
      _SCREAMING_SNAKE_CASE      =				(2, 2, 6, 2)
      _SCREAMING_SNAKE_CASE      =				(3, 6, 12, 24)
   elif "small" in model_name:
      _SCREAMING_SNAKE_CASE      =				96
      _SCREAMING_SNAKE_CASE      =				(2, 2, 18, 2)
      _SCREAMING_SNAKE_CASE      =				(3, 6, 12, 24)
   elif "base" in model_name:
      _SCREAMING_SNAKE_CASE      =				1_28
      _SCREAMING_SNAKE_CASE      =				(2, 2, 18, 2)
      _SCREAMING_SNAKE_CASE      =				(4, 8, 16, 32)
      _SCREAMING_SNAKE_CASE      =				12
      _SCREAMING_SNAKE_CASE      =				5_12
   elif "large" in model_name:
      _SCREAMING_SNAKE_CASE      =				1_92
      _SCREAMING_SNAKE_CASE      =				(2, 2, 18, 2)
      _SCREAMING_SNAKE_CASE      =				(6, 12, 24, 48)
      _SCREAMING_SNAKE_CASE      =				12
      _SCREAMING_SNAKE_CASE      =				7_68

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

   _SCREAMING_SNAKE_CASE      =				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"""]    ,      )
   _SCREAMING_SNAKE_CASE      =				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"""
   _SCREAMING_SNAKE_CASE      =				[]

   # 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_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)     ->     int:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				dct.pop(SCREAMING_SNAKE_CASE_						)
   _SCREAMING_SNAKE_CASE      =				val
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)     ->     int:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				[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      =				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      =				state_dict.pop(F"backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"						)
         _SCREAMING_SNAKE_CASE      =				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      =				in_proj_weight[:dim, :]
         _SCREAMING_SNAKE_CASE      =				in_proj_bias[: dim]
         _SCREAMING_SNAKE_CASE      =				in_proj_weight[
             dim : dim * 2, :
         ]
         _SCREAMING_SNAKE_CASE      =				in_proj_bias[
             dim : dim * 2
         ]
         _SCREAMING_SNAKE_CASE      =				in_proj_weight[
             -dim :, :
         ]
         _SCREAMING_SNAKE_CASE      =				in_proj_bias[-dim :]
         # fmt: on
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     int:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				x.shape
   _SCREAMING_SNAKE_CASE      =				x.reshape(SCREAMING_SNAKE_CASE_    ,      4    ,      in_channel // 4						)
   _SCREAMING_SNAKE_CASE      =				x[:, [0, 2, 1, 3], :].transpose(1    ,      2						).reshape(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)
   return x
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     Dict:




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

   return x
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     List[Any]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				x.shape[0]
   _SCREAMING_SNAKE_CASE      =				x.reshape(4    ,      in_channel // 4						)
   _SCREAMING_SNAKE_CASE      =				x[[0, 2, 1, 3], :].transpose(0    ,      1						).reshape(SCREAMING_SNAKE_CASE_						)
   return x
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     Optional[Any]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				x.shape[0]
   _SCREAMING_SNAKE_CASE      =				x.reshape(in_channel // 4    ,      4						)
   _SCREAMING_SNAKE_CASE      =				x[:, [0, 2, 1, 3]].transpose(0    ,      1						).reshape(SCREAMING_SNAKE_CASE_						)
   return x
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)     ->     List[str]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				{
       """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      =				model_name_to_url[model_name]
   _SCREAMING_SNAKE_CASE      =				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						)

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

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

   # rename keys
   _SCREAMING_SNAKE_CASE      =				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:
            _SCREAMING_SNAKE_CASE      =				reverse_correct_unfold_reduction_order(SCREAMING_SNAKE_CASE_						)
         if "norm" in key:
            _SCREAMING_SNAKE_CASE      =				reverse_correct_unfold_norm_order(SCREAMING_SNAKE_CASE_						)

   model.load_state_dict(SCREAMING_SNAKE_CASE_						)

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

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

   with torch.no_grad():
      _SCREAMING_SNAKE_CASE      =				model(SCREAMING_SNAKE_CASE_						)
      _SCREAMING_SNAKE_CASE      =				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      =				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      =				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      =				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      =				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__      :		Optional[Any]       							=  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__      :		Union[str, Any]       							=  parser.parse_args()
     convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








'''simple docstring'''



from __future__ import annotations
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)     ->     Tuple:




   """simple docstring"""
   print(F"Vertex\tShortest Distance from vertex {src}"						)
   for i, d in enumerate(SCREAMING_SNAKE_CASE_						):
      print(F"{i}\t\t{d}"						)
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)     ->     List[Any]:




   """simple docstring"""
   for j in range(SCREAMING_SNAKE_CASE_						):
      _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				(graph[j][k] for k in ["""src""", """dst""", """weight"""])
      if distance[u] != float("""inf"""						) and distance[u] + w < distance[v]:
         return True
   return False
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)     ->     list[float]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				[float("""inf"""						)] * vertex_count
   _SCREAMING_SNAKE_CASE      =				0.0

   for _ in range(vertex_count - 1						):
      for j in range(SCREAMING_SNAKE_CASE_						):
         _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				(graph[j][k] for k in ["""src""", """dst""", """weight"""])

         if distance[u] != float("""inf"""						) and distance[u] + w < distance[v]:
            _SCREAMING_SNAKE_CASE      =				distance[u] + w

   _SCREAMING_SNAKE_CASE      =				check_negative_cycle(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)
   if negative_cycle_exists:
      raise Exception("""Negative cycle found"""						)

   return distance


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     UpperCamelCase__      :		int       							=  int(input("Enter number of vertices: ").strip())
     UpperCamelCase__      :		int       							=  int(input("Enter number of edges: ").strip())

     UpperCamelCase__      :		list[dict[str, int]]       							=  [{} for _ in range(E)]

     for i in range(E):
          print("Edge ", i + 1)
          UpperCamelCase__							,      UpperCamelCase__							,      UpperCamelCase__      :		Dict       							=  (
              int(x)
              for x in input("Enter source, destination, weight: ").strip().split(" ")
          )
          UpperCamelCase__      :		Optional[Any]       							=  {"src": src, "dst": dest, "weight": weight}

     UpperCamelCase__      :		Optional[Any]       							=  int(input("\nEnter shortest path source:").strip())
     UpperCamelCase__      :		Any       							=  bellman_ford(graph, V, E, source)
     print_distance(shortest_distance, 0)






