"""simple docstring"""







import argparse
import json
from pathlib import Path

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

from transformers import YolosConfig, YolosForObjectDetection, YolosImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
_a					:					List[Any]=			logging.get_logger(__name__)
def   __UpperCAmelCase    (   UpperCAmelCase_   :    str  )							->      YolosConfig:

	'''simple docstring'''





	__snake_case      :							Optional[int]						=			YolosConfig()

	# size of the architecture
	if "yolos_ti" in yolos_name:
		__snake_case      :							Optional[Any]						=			1_92
		__snake_case      :							Optional[Any]						=			7_68
		__snake_case      :							int						=			12
		__snake_case      :							Dict						=			3
		__snake_case      :							Tuple						=			[8_00, 13_33]
		__snake_case      :							Tuple						=			False
	elif yolos_name == "yolos_s_dWr":
		__snake_case      :							List[Any]						=			3_30
		__snake_case      :							List[str]						=			14
		__snake_case      :							Union[str, Any]						=			6
		__snake_case      :							Dict						=			13_20
	elif "yolos_s" in yolos_name:
		__snake_case      :							Optional[int]						=			3_84
		__snake_case      :							Tuple						=			15_36
		__snake_case      :							str						=			12
		__snake_case      :							int						=			6
	elif "yolos_b" in yolos_name:
		__snake_case      :							Optional[int]						=			[8_00, 13_44]

	__snake_case      :							str						=			91
	__snake_case      :							int						=			'huggingface/label-files'
	__snake_case      :							List[Any]						=			'coco-detection-id2label.json'
	__snake_case      :							int						=			json.load(open(hf_hub_download(UpperCAmelCase_      ,							UpperCAmelCase_      ,							repo_type='dataset'  )      ,							'r'  )  )
	__snake_case      :							Optional[Any]						=			{int(UpperCAmelCase_  ): v for k, v in idalabel.items()}
	__snake_case      :							Union[str, Any]						=			idalabel
	__snake_case      :							Union[str, Any]						=			{v: k for k, v in idalabel.items()}

	return config
def   __UpperCAmelCase    (   UpperCAmelCase_   :    dict      ,							UpperCAmelCase_   :    YolosConfig      ,							UpperCAmelCase_   :    bool = False  )							->      str:

	'''simple docstring'''





	for i in range(config.num_hidden_layers  ):
		# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
		__snake_case      :							Any						=			state_dict.pop(F"blocks.{i}.attn.qkv.weight"  )
		__snake_case      :							Any						=			state_dict.pop(F"blocks.{i}.attn.qkv.bias"  )
		# next, add query, keys and values (in that order) to the state dict
		__snake_case      :							Dict						=			in_proj_weight[: config.hidden_size, :]
		__snake_case      :							Any						=			in_proj_bias[: config.hidden_size]
		__snake_case      :							Any						=			in_proj_weight[
		    config.hidden_size : config.hidden_size * 2, :
		]
		__snake_case      :							Any						=			in_proj_bias[
		    config.hidden_size : config.hidden_size * 2
		]
		__snake_case      :							int						=			in_proj_weight[-config.hidden_size :, :]
		__snake_case      :							List[str]						=			in_proj_bias[-config.hidden_size :]
def   __UpperCAmelCase    (   UpperCAmelCase_   :    str  )							->      str:

	'''simple docstring'''





	if "backbone" in name:
		__snake_case      :							Dict						=			name.replace('backbone'      ,							'vit'  )
	if "cls_token" in name:
		__snake_case      :							Any						=			name.replace('cls_token'      ,							'embeddings.cls_token'  )
	if "det_token" in name:
		__snake_case      :							Optional[int]						=			name.replace('det_token'      ,							'embeddings.detection_tokens'  )
	if "mid_pos_embed" in name:
		__snake_case      :							List[str]						=			name.replace('mid_pos_embed'      ,							'encoder.mid_position_embeddings'  )
	if "pos_embed" in name:
		__snake_case      :							Any						=			name.replace('pos_embed'      ,							'embeddings.position_embeddings'  )
	if "patch_embed.proj" in name:
		__snake_case      :							str						=			name.replace('patch_embed.proj'      ,							'embeddings.patch_embeddings.projection'  )
	if "blocks" in name:
		__snake_case      :							List[Any]						=			name.replace('blocks'      ,							'encoder.layer'  )
	if "attn.proj" in name:
		__snake_case      :							Any						=			name.replace('attn.proj'      ,							'attention.output.dense'  )
	if "attn" in name:
		__snake_case      :							Dict						=			name.replace('attn'      ,							'attention.self'  )
	if "norm1" in name:
		__snake_case      :							Optional[int]						=			name.replace('norm1'      ,							'layernorm_before'  )
	if "norm2" in name:
		__snake_case      :							Optional[Any]						=			name.replace('norm2'      ,							'layernorm_after'  )
	if "mlp.fc1" in name:
		__snake_case      :							List[str]						=			name.replace('mlp.fc1'      ,							'intermediate.dense'  )
	if "mlp.fc2" in name:
		__snake_case      :							Optional[Any]						=			name.replace('mlp.fc2'      ,							'output.dense'  )
	if "class_embed" in name:
		__snake_case      :							Optional[Any]						=			name.replace('class_embed'      ,							'class_labels_classifier'  )
	if "bbox_embed" in name:
		__snake_case      :							int						=			name.replace('bbox_embed'      ,							'bbox_predictor'  )
	if "vit.norm" in name:
		__snake_case      :							Any						=			name.replace('vit.norm'      ,							'vit.layernorm'  )

	return name
def   __UpperCAmelCase    (   UpperCAmelCase_   :    dict      ,							UpperCAmelCase_   :    YolosForObjectDetection  )							->      dict:

	'''simple docstring'''





	for key in orig_state_dict.copy().keys():
		__snake_case      :							int						=			orig_state_dict.pop(UpperCAmelCase_  )

		if "qkv" in key:
			__snake_case      :							str						=			key.split('.'  )
			__snake_case      :							int						=			int(key_split[2]  )
			__snake_case      :							Tuple						=			model.vit.encoder.layer[layer_num].attention.attention.all_head_size
			if "weight" in key:
				__snake_case      :							Any						=			val[:dim, :]
				__snake_case      :							Union[str, Any]						=			val[
				    dim : dim * 2, :
				]
				__snake_case      :							Any						=			val[-dim:, :]
			else:
				__snake_case      :							Optional[int]						=			val[:dim]
				__snake_case      :							List[str]						=			val[dim : dim * 2]
				__snake_case      :							List[Any]						=			val[-dim:]
		else:
			__snake_case      :							Tuple						=			val

	return orig_state_dict
def   __UpperCAmelCase    (   )							->      torch.Tensor:

	'''simple docstring'''





	__snake_case      :							Union[str, Any]						=			'http://images.cocodataset.org/val2017/000000039769.jpg'
	__snake_case      :							List[Any]						=			Image.open(requests.get(UpperCAmelCase_      ,							stream=UpperCAmelCase_  ).raw  )
	return im
@torch.no_grad()
def   __UpperCAmelCase    (   UpperCAmelCase_   :    str      ,							UpperCAmelCase_   :    str      ,							UpperCAmelCase_   :    str      ,							UpperCAmelCase_   :    bool = False  )							->      int:

	'''simple docstring'''





	__snake_case      :							Optional[Any]						=			get_yolos_config(UpperCAmelCase_  )

	# load original state_dict
	__snake_case      :							Union[str, Any]						=			torch.load(UpperCAmelCase_      ,							map_location='cpu'  )['model']

	# load 🤗 model
	__snake_case      :							Optional[Any]						=			YolosForObjectDetection(UpperCAmelCase_  )
	model.eval()
	__snake_case      :							int						=			convert_state_dict(UpperCAmelCase_      ,							UpperCAmelCase_  )
	model.load_state_dict(UpperCAmelCase_  )

	# Check outputs on an image, prepared by YolosImageProcessor
	__snake_case      :							Optional[Any]						=			8_00 if yolos_name != 'yolos_ti' else 5_12
	__snake_case      :							Dict						=			YolosImageProcessor(format='coco_detection'      ,							size=UpperCAmelCase_  )
	__snake_case      :							int						=			image_processor(images=prepare_img()      ,							return_tensors='pt'  )
	__snake_case      :							int						=			model(**UpperCAmelCase_  )
	__snake_case      :							List[str]						=			outputs.logits, outputs.pred_boxes

	__snake_case      :							Dict						=			None, None
	if yolos_name == "yolos_ti":
		__snake_case      :							Dict						=			torch.tensor(
		    [[-39.5_022, -11.9_820, -17.6_888], [-29.9_574, -9.9_769, -17.7_691], [-42.3_281, -20.7_200, -30.6_294]]  )
		__snake_case      :							Tuple						=			torch.tensor(
		    [[0.4_021, 0.0_836, 0.7_979], [0.0_184, 0.2_609, 0.0_364], [0.1_781, 0.2_004, 0.2_095]]  )
	elif yolos_name == "yolos_s_200_pre":
		__snake_case      :							Tuple						=			torch.tensor(
		    [[-24.0_248, -10.3_024, -14.8_290], [-42.0_392, -16.8_200, -27.4_334], [-27.2_743, -11.8_154, -18.7_148]]  )
		__snake_case      :							Tuple						=			torch.tensor(
		    [[0.2_559, 0.5_455, 0.4_706], [0.2_989, 0.7_279, 0.1_875], [0.7_732, 0.4_017, 0.4_462]]  )
	elif yolos_name == "yolos_s_300_pre":
		__snake_case      :							Optional[Any]						=			torch.tensor(
		    [[-36.2_220, -14.4_385, -23.5_457], [-35.6_970, -14.7_583, -21.3_935], [-31.5_939, -13.6_042, -16.8_049]]  )
		__snake_case      :							Tuple						=			torch.tensor(
		    [[0.7_614, 0.2_316, 0.4_728], [0.7_168, 0.4_495, 0.3_855], [0.4_996, 0.1_466, 0.9_996]]  )
	elif yolos_name == "yolos_s_dWr":
		__snake_case      :							str						=			torch.tensor(
		    [[-42.8_668, -24.1_049, -41.1_690], [-34.7_456, -14.1_274, -24.9_194], [-33.7_898, -12.1_946, -25.6_495]]  )
		__snake_case      :							Tuple						=			torch.tensor(
		    [[0.5_587, 0.2_773, 0.0_605], [0.5_004, 0.3_014, 0.9_994], [0.4_999, 0.1_548, 0.9_994]]  )
	elif yolos_name == "yolos_base":
		__snake_case      :							str						=			torch.tensor(
		    [[-40.6_064, -24.3_084, -32.6_447], [-55.1_990, -30.7_719, -35.5_877], [-51.4_311, -33.3_507, -35.6_462]]  )
		__snake_case      :							Dict						=			torch.tensor(
		    [[0.5_555, 0.2_794, 0.0_655], [0.9_049, 0.2_664, 0.1_894], [0.9_183, 0.1_984, 0.1_635]]  )
	else:
		raise ValueError(F"Unknown yolos_name: {yolos_name}"  )

	assert torch.allclose(logits[0, :3, :3]      ,							UpperCAmelCase_      ,							atol=1E-4  )
	assert torch.allclose(pred_boxes[0, :3, :3]      ,							UpperCAmelCase_      ,							atol=1E-4  )

	Path(UpperCAmelCase_  ).mkdir(exist_ok=UpperCAmelCase_  )
	print(F"Saving model {yolos_name} 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 push_to_hub:
		__snake_case      :							Any						=			{
		    'yolos_ti': 'yolos-tiny',
		    'yolos_s_200_pre': 'yolos-small',
		    'yolos_s_300_pre': 'yolos-small-300',
		    'yolos_s_dWr': 'yolos-small-dwr',
		    'yolos_base': 'yolos-base',
		}

		print('Pushing to the hub...'  )
		__snake_case      :							Optional[int]						=			model_mapping[yolos_name]
		image_processor.push_to_hub(UpperCAmelCase_      ,							organization='hustvl'  )
		model.push_to_hub(UpperCAmelCase_      ,							organization='hustvl'  )


if __name__ == "__main__":
	_a					:					Any=			argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    "--yolos_name",
	    default="yolos_s_200_pre",
	    type=str,
	    help=(
	        "Name of the YOLOS model you'd like to convert. Should be one of 'yolos_ti', 'yolos_s_200_pre',"
	        " 'yolos_s_300_pre', 'yolos_s_dWr', 'yolos_base'."
	    ),
	)
	parser.add_argument(
	    "--checkpoint_path", default=None, type=str, help="Path to the original state dict (.pth file)."
	)
	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					:					str=			parser.parse_args()
	convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)





"""simple docstring"""







import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_funnel import FunnelTokenizer


_a					:					Any=			logging.get_logger(__name__)

_a					:					str=			{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

_a					:					Optional[Any]=			[
    "small",
    "small-base",
    "medium",
    "medium-base",
    "intermediate",
    "intermediate-base",
    "large",
    "large-base",
    "xlarge",
    "xlarge-base",
]

_a					:					List[Any]=			{
    "vocab_file": {
        "funnel-transformer/small": "https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt",
        "funnel-transformer/small-base": "https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt",
        "funnel-transformer/medium": "https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt",
        "funnel-transformer/medium-base": (
            "https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt"
        ),
        "funnel-transformer/intermediate": (
            "https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt"
        ),
        "funnel-transformer/intermediate-base": (
            "https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt"
        ),
        "funnel-transformer/large": "https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt",
        "funnel-transformer/large-base": "https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt",
        "funnel-transformer/xlarge": "https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt",
        "funnel-transformer/xlarge-base": (
            "https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "funnel-transformer/small": "https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json",
        "funnel-transformer/small-base": (
            "https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json"
        ),
        "funnel-transformer/medium": "https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json",
        "funnel-transformer/medium-base": (
            "https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json"
        ),
        "funnel-transformer/intermediate": (
            "https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json"
        ),
        "funnel-transformer/intermediate-base": (
            "https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json"
        ),
        "funnel-transformer/large": "https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json",
        "funnel-transformer/large-base": (
            "https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json"
        ),
        "funnel-transformer/xlarge": "https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json",
        "funnel-transformer/xlarge-base": (
            "https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json"
        ),
    },
}
_a					:					str=			{f'''funnel-transformer/{name}''': 512 for name in _model_names}
_a					:					List[Any]=			{f'''funnel-transformer/{name}''': {"do_lower_case": True} for name in _model_names}

class 		UpperCamelCase      (   lowercase						):
				UpperCAmelCase    :				List[str]   =		VOCAB_FILES_NAMES
				UpperCAmelCase    :				Tuple   =		PRETRAINED_VOCAB_FILES_MAP
				UpperCAmelCase    :				int   =		PRETRAINED_INIT_CONFIGURATION
				UpperCAmelCase    :				Tuple   =		FunnelTokenizer
				UpperCAmelCase    :				Tuple   =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				UpperCAmelCase    :				int   =		2



				def __init__(self    :				int     ,  _A    :				Any=None     ,  _A    :				Union[str, Any]=None     ,  _A    :				Union[str, Any]=True     ,  _A    :				List[str]="<unk>"     ,  _A    :				Any="<sep>"     ,  _A    :				Dict="<pad>"     ,  _A    :				Tuple="<cls>"     ,  _A    :				Dict="<mask>"     ,  _A    :				Optional[Any]="<s>"     ,  _A    :				List[Any]="</s>"     ,  _A    :				Optional[int]=True     ,  _A    :				Dict=True     ,  _A    :				Tuple=None     ,  _A    :				int="##"     ,  **_A    :				Any     ,  )   ->     str:
					super().__init__(
					    _A     ,  tokenizer_file=_A     ,  do_lower_case=_A     ,  unk_token=_A     ,  sep_token=_A     ,  pad_token=_A     ,  cls_token=_A     ,  mask_token=_A     ,  bos_token=_A     ,  eos_token=_A     ,  clean_text=_A     ,  tokenize_chinese_chars=_A     ,  strip_accents=_A     ,  wordpieces_prefix=_A     ,  **_A     ,  )

					__snake_case      :							Optional[int]						=			json.loads(self.backend_tokenizer.normalizer.__getstate__())
					if (
					    normalizer_state.get('lowercase'     ,  _A) != do_lower_case
					    or normalizer_state.get('strip_accents'     ,  _A) != strip_accents
					    or normalizer_state.get('handle_chinese_chars'     ,  _A) != tokenize_chinese_chars
					):
						__snake_case      :							List[str]						=			getattr(_A     ,  normalizer_state.pop('type'))
						__snake_case      :							int						=			do_lower_case
						__snake_case      :							Optional[int]						=			strip_accents
						__snake_case      :							str						=			tokenize_chinese_chars
						__snake_case      :							Optional[int]						=			normalizer_class(**_A)

					__snake_case      :							str						=			do_lower_case



				def  _lowercase					(self    :				Optional[Any]     ,  _A    :				Dict     ,  _A    :				Tuple=None)   ->     Any:
					__snake_case      :							List[Any]						=			[self.cls_token_id] + token_ids_a + [self.sep_token_id]

					if token_ids_a:
						output += token_ids_a + [self.sep_token_id]

					return output



				def  _lowercase					(self    :				str     ,  _A    :				List[int]     ,  _A    :				Optional[List[int]] = None)   ->     List[int]:
					__snake_case      :							Union[str, Any]						=			[self.sep_token_id]
					__snake_case      :							Union[str, Any]						=			[self.cls_token_id]
					if token_ids_a is None:
						return len(cls) * [self.cls_token_type_id] + len(token_ids_a + sep) * [0]
					return len(cls) * [self.cls_token_type_id] + len(token_ids_a + sep) * [0] + len(token_ids_a + sep) * [1]






				def  _lowercase					(self    :				Tuple     ,  _A    :				str     ,  _A    :				Optional[str] = None)   ->     Tuple[str]:
					__snake_case      :							int						=			self._tokenizer.model.save(_A     ,  name=_A)
					return tuple(_A)





