


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()
snake_case__  				=			logging.get_logger(__name__)
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:Any   ,    lowercase__	:int=False   ,    lowercase__	:List[str]=False					)							->	str:
						__magic_name__					:				Any				=   'backbone.' if is_semantic else ''

						__magic_name__					:				Any				=   []
						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 			__SCREAMING_SNAKE_CASE							(					lowercase__	:List[Any]   ,    lowercase__	:str   ,    lowercase__	:int=False   ,    lowercase__	:Optional[Any]=False					)							->	List[str]:
						for i in range(config.num_hidden_layers					):
												__magic_name__					:				Dict				=   'backbone.' if is_semantic else ''
												# queries, keys and values
												__magic_name__					:				Tuple				=   state_dict.pop(f"{prefix}blocks.{i}.attn.qkv.weight"					)
												__magic_name__					:				Optional[Any]				=   state_dict.pop(f"{prefix}blocks.{i}.attn.q_bias"					)
												__magic_name__					:				int				=   state_dict.pop(f"{prefix}blocks.{i}.attn.v_bias"					)

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

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

												__magic_name__					:				Optional[int]				=   gamma_a
												__magic_name__					:				Union[str, Any]				=   gamma_a

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

																		__magic_name__					:				Any				=   table
																		__magic_name__					:				str				=   index
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:Dict   ,    lowercase__	:Tuple   ,    lowercase__	:Any					)							->	List[str]:
						__magic_name__					:				Any				=   dct.pop(lowercase__					)
						__magic_name__					:				List[Any]				=   val
def 			__SCREAMING_SNAKE_CASE							(					)							->	Union[str, Any]:
						__magic_name__					:				int				=   'http://images.cocodataset.org/val2017/000000039769.jpg'
						__magic_name__					:				List[str]				=   Image.open(requests.get(lowercase__   ,    stream=lowercase__					).raw					)
						return im
@torch.no_grad()
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:List[Any]   ,    lowercase__	:Optional[int]					)							->	Any:
						__magic_name__					:				Dict				=   BeitConfig()
						__magic_name__					:				str				=   False
						__magic_name__					:				Tuple				=   False
						__magic_name__					:				Dict				=   'huggingface/label-files'
						# set config parameters based on URL
						if checkpoint_url[-9:-4] == "pt22k":
												# masked image modeling
												__magic_name__					:				Dict				=   True
												__magic_name__					:				Optional[int]				=   True
												__magic_name__					:				int				=   True
						elif checkpoint_url[-9:-4] == "ft22k":
												# intermediate fine-tuning on ImageNet-22k
												__magic_name__					:				List[Any]				=   True
												__magic_name__					:				List[Any]				=   2_1_8_4_1
												__magic_name__					:				Union[str, Any]				=   'imagenet-22k-id2label.json'
												__magic_name__					:				Optional[Any]				=   json.load(open(hf_hub_download(lowercase__   ,    lowercase__   ,    repo_type='dataset'					)   ,    'r'					)					)
												__magic_name__					:				int				=   {int(lowercase__					): 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]
												__magic_name__					:				Union[str, Any]				=   idalabel
												__magic_name__					:				Tuple				=   {v: k for k, v in idalabel.items()}
						elif checkpoint_url[-8:-4] == "to1k":
												# fine-tuning on ImageNet-1k
												__magic_name__					:				Optional[Any]				=   True
												__magic_name__					:				Optional[Any]				=   1_0_0_0
												__magic_name__					:				List[str]				=   'imagenet-1k-id2label.json'
												__magic_name__					:				Optional[Any]				=   json.load(open(hf_hub_download(lowercase__   ,    lowercase__   ,    repo_type='dataset'					)   ,    'r'					)					)
												__magic_name__					:				List[Any]				=   {int(lowercase__					): v for k, v in idalabel.items()}
												__magic_name__					:				Tuple				=   idalabel
												__magic_name__					:				Dict				=   {v: k for k, v in idalabel.items()}
												if "384" in checkpoint_url:
																		__magic_name__					:				Any				=   3_8_4
												if "512" in checkpoint_url:
																		__magic_name__					:				Optional[Any]				=   5_1_2
						elif "ade20k" in checkpoint_url:
												# fine-tuning
												__magic_name__					:				Any				=   True
												__magic_name__					:				List[Any]				=   1_5_0
												__magic_name__					:				Dict				=   'ade20k-id2label.json'
												__magic_name__					:				Union[str, Any]				=   json.load(open(hf_hub_download(lowercase__   ,    lowercase__   ,    repo_type='dataset'					)   ,    'r'					)					)
												__magic_name__					:				Optional[Any]				=   {int(lowercase__					): v for k, v in idalabel.items()}
												__magic_name__					:				Optional[int]				=   idalabel
												__magic_name__					:				Any				=   {v: k for k, v in idalabel.items()}
												__magic_name__					:				str				=   6_4_0
												__magic_name__					:				List[str]				=   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:
												__magic_name__					:				Any				=   1_0_2_4
												__magic_name__					:				Union[str, Any]				=   4_0_9_6
												__magic_name__					:				str				=   2_4
												__magic_name__					:				int				=   1_6
												if "ade20k" in checkpoint_url:
																		__magic_name__					:				Optional[int]				=   6_4_0
																		__magic_name__					:				Optional[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
						__magic_name__					:				Optional[Any]				=   torch.hub.load_state_dict_from_url(lowercase__   ,    map_location='cpu'   ,    check_hash=lowercase__					)
						__magic_name__					:				Tuple				=   state_dict['model'] if 'ade20k' not in checkpoint_url else state_dict['state_dict']

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

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

						# Check outputs on an image
						if is_semantic:
												__magic_name__					:				List[Any]				=   BeitImageProcessor(size=config.image_size   ,    do_center_crop=lowercase__					)
												__magic_name__					:				Union[str, Any]				=   load_dataset('hf-internal-testing/fixtures_ade20k'   ,    split='test'					)
												__magic_name__					:				List[Any]				=   Image.open(ds[0]['file']					)
						else:
												__magic_name__					:				Union[str, Any]				=   BeitImageProcessor(
												    size=config.image_size   ,    resample=PILImageResampling.BILINEAR   ,    do_center_crop=lowercase__					)
												__magic_name__					:				str				=   prepare_img()

						__magic_name__					:				List[Any]				=   image_processor(images=lowercase__   ,    return_tensors='pt'					)
						__magic_name__					:				Union[str, Any]				=   encoding['pixel_values']

						__magic_name__					:				Dict				=   model(lowercase__					)
						__magic_name__					:				Tuple				=   outputs.logits

						# verify logits
						__magic_name__					:				Optional[Any]				=   torch.Size([1, 1_0_0_0]					)
						if checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k'					):
												__magic_name__					:				Any				=   torch.Size([1, 1_9_6, 8_1_9_2]					)
						elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k'					):
												__magic_name__					:				Dict				=   torch.Size([1, 1_9_6, 8_1_9_2]					)
						elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft22k'					):
												__magic_name__					:				Optional[int]				=   torch.Size([1, 2_1_8_4_1]					)
												__magic_name__					:				Dict				=   torch.tensor([2.2_2_8_8, 2.4_6_7_1, 0.7_3_9_5]					)
												__magic_name__					:				str				=   2_3_9_7
						elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft22k'					):
												__magic_name__					:				Dict				=   torch.Size([1, 2_1_8_4_1]					)
												__magic_name__					:				Any				=   torch.tensor([1.6_8_8_1, -0.2_7_8_7, 0.5_9_0_1]					)
												__magic_name__					:				Tuple				=   2_3_9_6
						elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft1k'					):
												__magic_name__					:				Dict				=   torch.tensor([0.1_2_4_1, 0.0_7_9_8, -0.6_5_6_9]					)
												__magic_name__					:				List[Any]				=   2_8_5
						elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft22kto1k'					):
												__magic_name__					:				int				=   torch.tensor([-1.2_3_8_5, -1.0_9_8_7, -1.0_1_0_8]					)
												__magic_name__					:				Optional[Any]				=   2_8_1
						elif checkpoint_url[:-4].endswith('beit_base_patch16_384_pt22k_ft22kto1k'					):
												__magic_name__					:				List[Any]				=   torch.tensor([-1.5_3_0_3, -0.9_4_8_4, -0.3_1_4_7]					)
												__magic_name__					:				List[Any]				=   7_6_1
						elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft1k'					):
												__magic_name__					:				List[Any]				=   torch.tensor([0.4_6_1_0, -0.0_9_2_8, 0.2_0_8_6]					)
												__magic_name__					:				Optional[int]				=   7_6_1
						elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft22kto1k'					):
												__magic_name__					:				Any				=   torch.tensor([-0.4_8_0_4, 0.6_2_5_7, -0.1_8_3_7]					)
												__magic_name__					:				Optional[int]				=   7_6_1
						elif checkpoint_url[:-4].endswith('beit_large_patch16_384_pt22k_ft22kto1k'					):
												__magic_name__					:				Tuple				=   torch.tensor([[-0.5_1_2_2, 0.5_1_1_7, -0.2_1_1_3]]					)
												__magic_name__					:				Dict				=   7_6_1
						elif checkpoint_url[:-4].endswith('beit_large_patch16_512_pt22k_ft22kto1k'					):
												__magic_name__					:				Union[str, Any]				=   torch.tensor([-0.3_0_6_2, 0.7_2_6_1, 0.4_8_5_2]					)
												__magic_name__					:				Tuple				=   7_6_1
						elif checkpoint_url[:-4].endswith('beit_base_patch16_640_pt22k_ft22ktoade20k'					):
												__magic_name__					:				Optional[int]				=   (1, 1_5_0, 1_6_0, 1_6_0)
												__magic_name__					:				Any				=   torch.tensor(
												    [
												        [[-4.9_2_2_5, -2.3_9_5_4, -3.0_5_2_2], [-2.8_8_2_2, -1.0_0_4_6, -1.7_5_6_1], [-2.9_5_4_9, -1.3_2_2_8, -2.1_3_4_7]],
												        [[-5.8_1_6_8, -3.4_1_2_9, -4.0_7_7_8], [-3.8_6_5_1, -2.2_2_1_4, -3.0_2_7_7], [-3.8_3_5_6, -2.4_6_4_3, -3.3_5_3_5]],
												        [[-0.0_0_7_8, 3.9_9_5_2, 4.0_7_5_4], [2.9_8_5_6, 4.6_9_4_4, 5.0_0_3_5], [3.2_4_1_3, 4.7_8_1_3, 4.9_9_6_9]],
												    ]					)
						elif checkpoint_url[:-4].endswith('beit_large_patch16_640_pt22k_ft22ktoade20k'					):
												__magic_name__					:				str				=   (1, 1_5_0, 1_6_0, 1_6_0)
												__magic_name__					:				Tuple				=   torch.tensor(
												    [
												        [[-4.3_3_0_5, -2.3_0_4_9, -3.0_1_6_1], [-2.9_5_9_1, -1.5_3_0_5, -2.2_2_5_1], [-3.4_1_9_8, -1.8_0_0_4, -2.9_0_6_2]],
												        [[-5.8_9_2_2, -3.7_4_3_5, -4.3_9_7_8], [-4.2_0_6_3, -2.7_8_7_2, -3.4_7_5_5], [-4.2_7_9_1, -3.1_8_7_4, -4.1_6_8_1]],
												        [[0.9_8_9_5, 4.3_4_6_7, 4.7_6_6_3], [4.2_4_7_6, 5.6_8_3_0, 6.1_5_1_8], [4.5_5_5_0, 6.2_4_9_5, 6.5_1_5_4]],
												    ]					)
						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]   ,    lowercase__   ,    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]   ,    lowercase__   ,    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(lowercase__					).mkdir(exist_ok=lowercase__					)
						print(f"Saving model to {pytorch_dump_folder_path}"					)
						model.save_pretrained(lowercase__					)
						print(f"Saving image processor to {pytorch_dump_folder_path}"					)
						image_processor.save_pretrained(lowercase__					)


if __name__ == "__main__":
			snake_case__  				=			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.'
			)
			snake_case__  				=			parser.parse_args()
			convert_beit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)






from __future__ import annotations

import random
import string



class      snake_case__	:
				def __init__(	self  ,   _UpperCAmelCase = None   ):




										"""simple docstring"""




										__magic_name__					:				Union[str, Any]				=   passcode or self.__passcode_creator()
										__magic_name__					:				Any				=   self.__make_key_list()
										__magic_name__					:				Tuple				=   self.__make_shift_key()
				def __str__(	self   ):




										"""simple docstring"""




										return "".join(self.__passcode   )
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										for i in range(1  ,   len(_UpperCAmelCase   )  ,   2   ):
																iterlist[i] *= -1
										return iterlist
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Any				=   string.ascii_letters + string.digits
										__magic_name__					:				Optional[Any]				=   [random.choice(_UpperCAmelCase   ) for _ in range(random.randint(10  ,   20   )   )]
										return password
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Any				=   (
										    string.ascii_letters + string.digits + string.punctuation + ' \t\n'
										)

										__magic_name__					:				List[str]				=   []

										# creates points known as breakpoints to break the key_list_options at those
										# points and pivot each substring
										__magic_name__					:				List[Any]				=   sorted(set(self.__passcode   )   )
										__magic_name__					:				list[str]				=   []

										# algorithm for creating a new shuffled list, keys_l, out of key_list_options
										for i in key_list_options:
																temp_list.extend(_UpperCAmelCase   )

																# checking breakpoints at which to pivot temporary sublist and add it into
																# keys_l
																if i in breakpoints or i == key_list_options[-1]:
																						keys_l.extend(temp_list[::-1]   )
																						temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
										return keys_l
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Dict				=   sum(self.__neg_pos([ord(_UpperCAmelCase   ) for x in self.__passcode]   )   )
										return num if num > 0 else len(self.__passcode   )
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										__magic_name__					:				List[Any]				=   ''

										# decoding shift like Caesar cipher algorithm implementing negative shift or
										# reverse shift or left shift
										for i in encoded_message:
																__magic_name__					:				int				=   self.__key_list.index(_UpperCAmelCase   )
																decoded_message += self.__key_list[
																    (position - self.__shift_key) % -len(self.__key_list   )
																]

										return decoded_message





				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										__magic_name__					:				List[Any]				=   ''

										# encoding shift like Caesar cipher algorithm implementing positive shift or
										# forward shift or right shift
										for i in plaintext:
																__magic_name__					:				Dict				=   self.__key_list.index(_UpperCAmelCase   )
																encoded_message += self.__key_list[
																    (position + self.__shift_key) % len(self.__key_list   )
																]

										return encoded_message






def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:str = "Hello, this is a modified Caesar cipher"					)							->	str:
						__magic_name__					:				List[str]				=   ShuffledShiftCipher()
						return cipa.decrypt(cipa.encrypt(lowercase__					)					)


if __name__ == "__main__":
			import doctest

			doctest.testmod()


