



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	)  ->	Optional[Any]:







  """simple docstring"""





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

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

  lowerCamelCase__:   Tuple    						=SwinConfig(
      embed_dim=__a			,					depths=__a			,					num_heads=__a			,					window_size=__a			,					out_features=["stage1", "stage2", "stage3", "stage4"]			,					)
  lowerCamelCase__:   Dict    						=UperNetConfig(
      backbone_config=__a			,					auxiliary_in_channels=__a			,					num_labels=__a			,					idalabel=__a			,					labelaid=__a			,					)

  return config





def   lowerCAmelCase_				( __a	)  ->	Dict:







  """simple docstring"""





  lowerCamelCase__:   Tuple    						=[]

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







  """simple docstring"""





  lowerCamelCase__:   Tuple    						=dct.pop(__a	)
  lowerCamelCase__:   Any    						=val





def   lowerCAmelCase_				( __a			,					__a	)  ->	List[str]:







  """simple docstring"""





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





def   lowerCAmelCase_				( __a	)  ->	Dict:







  """simple docstring"""





  lowerCamelCase__:   str    						=x.shape
  lowerCamelCase__:   int    						=x.reshape(__a			,					4			,					in_channel // 4	)
  lowerCamelCase__:   Union[str, Any]    						=x[:, [0, 2, 1, 3], :].transpose(1			,					2	).reshape(__a			,					__a	)
  return x





def   lowerCAmelCase_				( __a	)  ->	Union[str, Any]:







  """simple docstring"""





  lowerCamelCase__:   Dict    						=x.shape
  lowerCamelCase__:   Dict    						=x.reshape(__a			,					in_channel // 4			,					4	)
  lowerCamelCase__:   Union[str, Any]    						=x[:, :, [0, 2, 1, 3]].transpose(1			,					2	).reshape(__a			,					__a	)

  return x





def   lowerCAmelCase_				( __a	)  ->	Any:







  """simple docstring"""





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





def   lowerCAmelCase_				( __a	)  ->	Optional[int]:







  """simple docstring"""





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





def   lowerCAmelCase_				( __a			,					__a			,					__a	)  ->	List[Any]:







  """simple docstring"""





  lowerCamelCase__:   List[str]    						={
      "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",
  }
  lowerCamelCase__:   Union[str, Any]    						=model_name_to_url[model_name]
  lowerCamelCase__:   Dict    						=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	)

  lowerCamelCase__:   str    						=get_upernet_config(__a	)
  lowerCamelCase__:   Any    						=UperNetForSemanticSegmentation(__a	)
  model.eval()

  # replace "bn" => "batch_norm"
  for key in state_dict.copy().keys():
    lowerCamelCase__:   str    						=state_dict.pop(__a	)
    if "bn" in key:
      lowerCamelCase__:   Tuple    						=key.replace("bn"			,					"batch_norm"	)
    lowerCamelCase__:   int    						=val

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

  model.load_state_dict(__a	)

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

  lowerCamelCase__:   List[Any]    						=SegformerImageProcessor()
  lowerCamelCase__:   str    						=processor(__a			,					return_tensors="pt"	).pixel_values

  with torch.no_grad():
    lowerCamelCase__:   Any    						=model(__a	)
    lowerCamelCase__:   Optional[int]    						=outputs.logits

  print(logits.shape	)
  print("First values of logits:"			,					logits[0, 0, :3, :3]	)
  # assert values
  if model_name == "upernet-swin-tiny":
    lowerCamelCase__:   Dict    						=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":
    lowerCamelCase__:   Tuple    						=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":
    lowerCamelCase__:   int    						=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":
    lowerCamelCase__:   Optional[Any]    						=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]			,					__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)








from __future__ import annotations





def   lowerCAmelCase_				( __a			,					__a			,					__a			,					)  ->	tuple:







  """simple docstring"""





  if (electron_conc, hole_conc, intrinsic_conc).count(0	) != 1:
    raise ValueError("You cannot supply more or less than 2 values"	)
  elif electron_conc < 0:
    raise ValueError("Electron concentration cannot be negative in a semiconductor"	)
  elif hole_conc < 0:
    raise ValueError("Hole concentration cannot be negative in a semiconductor"	)
  elif intrinsic_conc < 0:
    raise ValueError(
        "Intrinsic concentration cannot be negative in a semiconductor"	)
  elif electron_conc == 0:
    return (
        "electron_conc",
        intrinsic_conc**2 / hole_conc,
    )
  elif hole_conc == 0:
    return (
        "hole_conc",
        intrinsic_conc**2 / electron_conc,
    )
  elif intrinsic_conc == 0:
    return (
        "intrinsic_conc",
        (electron_conc * hole_conc) ** 0.5,
    )
  else:
    return (-1, -1)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

