






"""simple docstring"""


import argparse
import json
from pathlib import Path

import requests
import torch
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BeitConfig,
    BeitForImageClassification,
    BeitForMaskedImageModeling,
    BeitForSemanticSegmentation,
    BeitImageProcessor,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
_UpperCamelCase :    Union[str, Any]      =			logging.get_logger(__name__)




def 					a			(  UpperCamelCase_				:					Union[str, Any]  ,						UpperCamelCase_				:					List[Any]=False  ,						UpperCamelCase_				:					Optional[Any]=False		)	->		int:
 __A						:							Dict      =						'backbone.' if is_semantic else ''

 __A						:							str      =						[]
 for i in range(config.num_hidden_layers		):
  # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
  rename_keys.append((F"{prefix}blocks.{i}.norm1.weight", F"beit.encoder.layer.{i}.layernorm_before.weight")		)
  rename_keys.append((F"{prefix}blocks.{i}.norm1.bias", F"beit.encoder.layer.{i}.layernorm_before.bias")		)
  rename_keys.append(
      (F"{prefix}blocks.{i}.attn.proj.weight", F"beit.encoder.layer.{i}.attention.output.dense.weight")		)
  rename_keys.append(
      (F"{prefix}blocks.{i}.attn.proj.bias", F"beit.encoder.layer.{i}.attention.output.dense.bias")		)
  rename_keys.append((F"{prefix}blocks.{i}.norm2.weight", F"beit.encoder.layer.{i}.layernorm_after.weight")		)
  rename_keys.append((F"{prefix}blocks.{i}.norm2.bias", F"beit.encoder.layer.{i}.layernorm_after.bias")		)
  rename_keys.append((F"{prefix}blocks.{i}.mlp.fc1.weight", F"beit.encoder.layer.{i}.intermediate.dense.weight")		)
  rename_keys.append((F"{prefix}blocks.{i}.mlp.fc1.bias", F"beit.encoder.layer.{i}.intermediate.dense.bias")		)
  rename_keys.append((F"{prefix}blocks.{i}.mlp.fc2.weight", F"beit.encoder.layer.{i}.output.dense.weight")		)
  rename_keys.append((F"{prefix}blocks.{i}.mlp.fc2.bias", F"beit.encoder.layer.{i}.output.dense.bias")		)

 # projection layer + position embeddings
 rename_keys.extend(
     [
         (F"{prefix}cls_token", 'beit.embeddings.cls_token'),
         (F"{prefix}patch_embed.proj.weight", 'beit.embeddings.patch_embeddings.projection.weight'),
         (F"{prefix}patch_embed.proj.bias", 'beit.embeddings.patch_embeddings.projection.bias'),
     ]		)

 if has_lm_head:
  # mask token + shared relative position bias + layernorm
  rename_keys.extend(
      [
          ('mask_token', 'beit.embeddings.mask_token'),
          (
              'rel_pos_bias.relative_position_bias_table',
              'beit.encoder.relative_position_bias.relative_position_bias_table',
          ),
          (
              'rel_pos_bias.relative_position_index',
              'beit.encoder.relative_position_bias.relative_position_index',
          ),
          ('norm.weight', 'layernorm.weight'),
          ('norm.bias', 'layernorm.bias'),
      ]		)
 elif is_semantic:
  # semantic segmentation classification heads
  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'),
      ]		)
 else:
  # layernorm + classification head
  rename_keys.extend(
      [
          ('fc_norm.weight', 'beit.pooler.layernorm.weight'),
          ('fc_norm.bias', 'beit.pooler.layernorm.bias'),
          ('head.weight', 'classifier.weight'),
          ('head.bias', 'classifier.bias'),
      ]		)

 return rename_keys




def 					a			(  UpperCamelCase_				:					Optional[Any]  ,						UpperCamelCase_				:					List[str]  ,						UpperCamelCase_				:					Any=False  ,						UpperCamelCase_				:					Any=False		)	->		int:
 for i in range(config.num_hidden_layers		):
  __A						:							Union[str, Any]      =						'backbone.' if is_semantic else ''
  # queries, keys and values
  __A						:							Optional[Any]      =						state_dict.pop(F"{prefix}blocks.{i}.attn.qkv.weight"		)
  __A						:							Tuple      =						state_dict.pop(F"{prefix}blocks.{i}.attn.q_bias"		)
  __A						:							Optional[Any]      =						state_dict.pop(F"{prefix}blocks.{i}.attn.v_bias"		)

  __A						:							str      =						in_proj_weight[
      : config.hidden_size, :
  ]
  __A						:							str      =						q_bias
  __A						:							str      =						in_proj_weight[
      config.hidden_size : config.hidden_size * 2, :
  ]
  __A						:							Optional[int]      =						in_proj_weight[
      -config.hidden_size :, :
  ]
  __A						:							Any      =						v_bias

  # gamma_1 and gamma_2
  # we call them lambda because otherwise they are renamed when using .from_pretrained
  __A						:							Any      =						state_dict.pop(F"{prefix}blocks.{i}.gamma_1"		)
  __A						:							Any      =						state_dict.pop(F"{prefix}blocks.{i}.gamma_2"		)

  __A						:							List[str]      =						gamma_a
  __A						:							List[str]      =						gamma_a

  # relative_position bias table + index
  if not has_lm_head:
   # each layer has its own relative position bias
   __A						:							int      =						state_dict.pop(F"{prefix}blocks.{i}.attn.relative_position_bias_table"		)
   __A						:							Dict      =						state_dict.pop(F"{prefix}blocks.{i}.attn.relative_position_index"		)

   __A						:							Tuple      =						table
   __A						:							Any      =						index




def 					a			(  UpperCamelCase_				:					Tuple  ,						UpperCamelCase_				:					Any  ,						UpperCamelCase_				:					Optional[Any]		)	->		List[Any]:
 __A						:							Any      =						dct.pop(UpperCamelCase_		)
 __A						:							Optional[int]      =						val




def 					a			(  )	->		Dict:
 __A						:							Any      =						'http://images.cocodataset.org/val2017/000000039769.jpg'
 __A						:							int      =						Image.open(requests.get(UpperCamelCase_  ,						stream=UpperCamelCase_		).raw		)
 return im




@torch.no_grad()
def 					a			(  UpperCamelCase_				:					str  ,						UpperCamelCase_				:					str		)	->		Dict:
 __A						:							Dict      =						BeitConfig()
 __A						:							List[str]      =						False
 __A						:							Any      =						False
 __A						:							List[str]      =						'huggingface/label-files'
 # set config parameters based on URL
 if checkpoint_url[-9:-4] == "pt22k":
  # masked image modeling
  __A						:							Optional[Any]      =						True
  __A						:							List[Any]      =						True
  __A						:							Optional[int]      =						True
 elif checkpoint_url[-9:-4] == "ft22k":
  # intermediate fine-tuning on ImageNet-22k
  __A						:							Union[str, Any]      =						True
  __A						:							List[str]      =						2_1_8_4_1
  __A						:							List[Any]      =						'imagenet-22k-id2label.json'
  __A						:							Tuple      =						json.load(open(hf_hub_download(UpperCamelCase_  ,						UpperCamelCase_  ,						repo_type='dataset'		)  ,						'r'		)		)
  __A						:							Optional[int]      =						{int(UpperCamelCase_		): v for k, v in idalabel.items()}
  # this dataset contains 21843 labels but the model only has 21841
  # we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
  del idalabel[9_2_0_5]
  del idalabel[1_5_0_2_7]
  __A						:							Dict      =						idalabel
  __A						:							Union[str, Any]      =						{v: k for k, v in idalabel.items()}
 elif checkpoint_url[-8:-4] == "to1k":
  # fine-tuning on ImageNet-1k
  __A						:							Optional[int]      =						True
  __A						:							Tuple      =						1_0_0_0
  __A						:							str      =						'imagenet-1k-id2label.json'
  __A						:							Dict      =						json.load(open(hf_hub_download(UpperCamelCase_  ,						UpperCamelCase_  ,						repo_type='dataset'		)  ,						'r'		)		)
  __A						:							str      =						{int(UpperCamelCase_		): v for k, v in idalabel.items()}
  __A						:							Optional[Any]      =						idalabel
  __A						:							Union[str, Any]      =						{v: k for k, v in idalabel.items()}
  if "384" in checkpoint_url:
   __A						:							int      =						3_8_4
  if "512" in checkpoint_url:
   __A						:							str      =						5_1_2
 elif "ade20k" in checkpoint_url:
  # fine-tuning
  __A						:							int      =						True
  __A						:							Tuple      =						1_5_0
  __A						:							Dict      =						'ade20k-id2label.json'
  __A						:							List[str]      =						json.load(open(hf_hub_download(UpperCamelCase_  ,						UpperCamelCase_  ,						repo_type='dataset'		)  ,						'r'		)		)
  __A						:							int      =						{int(UpperCamelCase_		): v for k, v in idalabel.items()}
  __A						:							int      =						idalabel
  __A						:							int      =						{v: k for k, v in idalabel.items()}
  __A						:							Optional[Any]      =						6_4_0
  __A						:							Union[str, Any]      =						True
 else:
  raise ValueError('Checkpoint not supported, URL should either end with \'pt22k\', \'ft22k\', \'to1k\' or \'ade20k\''		)

 # size of the architecture
 if "base" in checkpoint_url:
  pass
 elif "large" in checkpoint_url:
  __A						:							Union[str, Any]      =						1_0_2_4
  __A						:							Any      =						4_0_9_6
  __A						:							List[str]      =						2_4
  __A						:							Optional[int]      =						1_6
  if "ade20k" in checkpoint_url:
   __A						:							List[Any]      =						6_4_0
   __A						:							List[Any]      =						[7, 1_1, 1_5, 2_3]
 else:
  raise ValueError('Should either find \'base\' or \'large\' in checkpoint URL'		)

 # load state_dict of original model, remove and rename some keys
 __A						:							Union[str, Any]      =						torch.hub.load_state_dict_from_url(UpperCamelCase_  ,						map_location='cpu'  ,						check_hash=UpperCamelCase_		)
 __A						:							int      =						state_dict['model'] if 'ade20k' not in checkpoint_url else state_dict['state_dict']

 __A						:							Optional[Any]      =						create_rename_keys(UpperCamelCase_  ,						has_lm_head=UpperCamelCase_  ,						is_semantic=UpperCamelCase_		)
 for src, dest in rename_keys:
  rename_key(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_		)
 read_in_q_k_v(UpperCamelCase_  ,						UpperCamelCase_  ,						has_lm_head=UpperCamelCase_  ,						is_semantic=UpperCamelCase_		)
 if is_semantic:
  # add prefix to decoder keys
  for key, val in state_dict.copy().items():
   __A						:							Tuple      =						state_dict.pop(UpperCamelCase_		)
   if key.startswith('backbone.fpn'		):
    __A						:							str      =						key.replace('backbone.fpn'  ,						'fpn'		)
   __A						:							List[str]      =						val

    # load HuggingFace model
 if checkpoint_url[-9:-4] == "pt22k":
  __A						:							Optional[Any]      =						BeitForMaskedImageModeling(UpperCamelCase_		)
 elif "ade20k" in checkpoint_url:
  __A						:							Optional[int]      =						BeitForSemanticSegmentation(UpperCamelCase_		)
 else:
  __A						:							List[str]      =						BeitForImageClassification(UpperCamelCase_		)
 model.eval()
 model.load_state_dict(UpperCamelCase_		)

 # Check outputs on an image
 if is_semantic:
  __A						:							Optional[Any]      =						BeitImageProcessor(size=config.image_size  ,						do_center_crop=UpperCamelCase_		)
  __A						:							Dict      =						load_dataset('hf-internal-testing/fixtures_ade20k'  ,						split='test'		)
  __A						:							int      =						Image.open(ds[0]['file']		)
 else:
  __A						:							Dict      =						BeitImageProcessor(
      size=config.image_size  ,						resample=PILImageResampling.BILINEAR  ,						do_center_crop=UpperCamelCase_		)
  __A						:							Tuple      =						prepare_img()

 __A						:							Dict      =						image_processor(images=UpperCamelCase_  ,						return_tensors='pt'		)
 __A						:							str      =						encoding['pixel_values']

 __A						:							Union[str, Any]      =						model(UpperCamelCase_		)
 __A						:							Optional[Any]      =						outputs.logits

 # verify logits
 __A						:							str      =						torch.Size([1, 1_0_0_0]		)
 if checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k'		):
  __A						:							Tuple      =						torch.Size([1, 1_9_6, 8_1_9_2]		)
 elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k'		):
  __A						:							int      =						torch.Size([1, 1_9_6, 8_1_9_2]		)
 elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft22k'		):
  __A						:							Any      =						torch.Size([1, 2_1_8_4_1]		)
  __A						:							List[str]      =						torch.tensor([2.2288, 2.4671, 0.7395]		)
  __A						:							Optional[Any]      =						2_3_9_7
 elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft22k'		):
  __A						:							int      =						torch.Size([1, 2_1_8_4_1]		)
  __A						:							Tuple      =						torch.tensor([1.6881, -0.2787, 0.5901]		)
  __A						:							Any      =						2_3_9_6
 elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft1k'		):
  __A						:							Any      =						torch.tensor([0.1241, 0.0798, -0.6569]		)
  __A						:							str      =						2_8_5
 elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft22kto1k'		):
  __A						:							List[str]      =						torch.tensor([-1.2385, -1.0987, -1.0108]		)
  __A						:							str      =						2_8_1
 elif checkpoint_url[:-4].endswith('beit_base_patch16_384_pt22k_ft22kto1k'		):
  __A						:							str      =						torch.tensor([-1.5303, -0.9484, -0.3147]		)
  __A						:							Dict      =						7_6_1
 elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft1k'		):
  __A						:							List[Any]      =						torch.tensor([0.4610, -0.0928, 0.2086]		)
  __A						:							Any      =						7_6_1
 elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft22kto1k'		):
  __A						:							Any      =						torch.tensor([-0.4804, 0.6257, -0.1837]		)
  __A						:							Union[str, Any]      =						7_6_1
 elif checkpoint_url[:-4].endswith('beit_large_patch16_384_pt22k_ft22kto1k'		):
  __A						:							int      =						torch.tensor([[-0.5122, 0.5117, -0.2113]]		)
  __A						:							str      =						7_6_1
 elif checkpoint_url[:-4].endswith('beit_large_patch16_512_pt22k_ft22kto1k'		):
  __A						:							List[str]      =						torch.tensor([-0.3062, 0.7261, 0.4852]		)
  __A						:							Dict      =						7_6_1
 elif checkpoint_url[:-4].endswith('beit_base_patch16_640_pt22k_ft22ktoade20k'		):
  __A						:							Dict      =						(1, 1_5_0, 1_6_0, 1_6_0)
  __A						:							Tuple      =						torch.tensor(
      [
          [[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
          [[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
          [[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
      ]		)
 elif checkpoint_url[:-4].endswith('beit_large_patch16_640_pt22k_ft22ktoade20k'		):
  __A						:							Tuple      =						(1, 1_5_0, 1_6_0, 1_6_0)
  __A						:							List[Any]      =						torch.tensor(
      [
          [[-4.3305, -2.3049, -3.0161], [-2.9591, -1.5305, -2.2251], [-3.4198, -1.8004, -2.9062]],
          [[-5.8922, -3.7435, -4.3978], [-4.2063, -2.7872, -3.4755], [-4.2791, -3.1874, -4.1681]],
          [[0.9895, 4.3467, 4.7663], [4.2476, 5.6830, 6.1518], [4.5550, 6.2495, 6.5154]],
      ]		)
 else:
  raise ValueError('Can\'t verify logits as model is not supported'		)

 assert logits.shape == expected_shape, "Shape of logits not as expected"
 if not has_lm_head:
  if is_semantic:
   assert torch.allclose(
       logits[0, :3, :3, :3]  ,						UpperCamelCase_  ,						atol=1E-3		), "First elements of logits not as expected"
  else:
   print('Predicted class idx:'  ,						logits.argmax(-1		).item()		)
   assert torch.allclose(
       logits[0, :3]  ,						UpperCamelCase_  ,						atol=1E-3		), "First elements of logits not as expected"
   assert logits.argmax(-1		).item() == expected_class_idx, "Predicted class index not as expected"

 Path(UpperCamelCase_		).mkdir(exist_ok=UpperCamelCase_		)
 print(F"Saving model to {pytorch_dump_folder_path}"		)
 model.save_pretrained(UpperCamelCase_		)
 print(F"Saving image processor to {pytorch_dump_folder_path}"		)
 image_processor.save_pretrained(UpperCamelCase_		)


if __name__ == "__main__":
   _UpperCamelCase :    Optional[Any]      =			argparse.ArgumentParser()

   parser.add_argument(
       """--checkpoint_url""",
       default="""https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22kto1k.pth""",
       type=str,
       help="""URL to the original PyTorch checkpoint (.pth file).""",
   )
   parser.add_argument(
       """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
   )
   _UpperCamelCase :    Dict      =			parser.parse_args()
   convert_beit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)













"""simple docstring"""


def 					a			(  UpperCamelCase_				:					float		)	->		int:
 return int(UpperCamelCase_		) if x - int(UpperCamelCase_		) <= 0 else int(UpperCamelCase_		) + 1


if __name__ == "__main__":
   import doctest

   doctest.testmod()





