

"""simple docstring"""






import argparse
from collections import OrderedDict
from pathlib import Path

import torch

from transformers import (
    VisualBertConfig,
    VisualBertForMultipleChoice,
    VisualBertForPreTraining,
    VisualBertForQuestionAnswering,
    VisualBertForVisualReasoning,
)
from transformers.utils import logging


logging.set_verbosity_info()
_lowercase				:				Any   		=		logging.get_logger(__name__)

_lowercase				:				Dict   		=		[
    ("bert.bert", "visual_bert"),
    ("bert.cls", "cls"),
    ("bert.classifier", "cls"),
    ("token_type_embeddings_visual", "visual_token_type_embeddings"),
    ("position_embeddings_visual", "visual_position_embeddings"),
    ("projection", "visual_projection"),
]

_lowercase				:				List[Any]   		=		[
    "nlvr2_coco_pre_trained.th",
    "nlvr2_fine_tuned.th",
    "nlvr2_pre_trained.th",
    "vcr_coco_pre_train.th",
    "vcr_fine_tune.th",
    "vcr_pre_train.th",
    "vqa_coco_pre_trained.th",
    "vqa_fine_tuned.th",
    "vqa_pre_trained.th",
]






def   snake_case__     (	__lowerCamelCase       :					Tuple			):
			"""simple docstring"""
			lowerCamelCase__	:	List[str]				=torch.load(__lowerCamelCase							,	map_location='''cpu'''			)
			return sd






def   snake_case__     (	__lowerCamelCase       :					Optional[int]							,	__lowerCamelCase       :					Tuple							,	__lowerCamelCase       :					Optional[int]=rename_keys_prefix			):
			"""simple docstring"""
			lowerCamelCase__	:	Dict				=OrderedDict()
			lowerCamelCase__	:	str				=torch.arange(config.max_position_embeddings			).expand((1, -1)			)
			# detector_d = OrderedDict()
			for key in d:
						if "detector" in key:
									# detector_d[key.replace('detector.','')] = d[key]
									continue
						lowerCamelCase__	:	Tuple				=key
						for name_pair in rename_keys_prefix:
									lowerCamelCase__	:	Optional[Any]				=new_key.replace(name_pair[0]							,	name_pair[1]			)
						lowerCamelCase__	:	List[str]				=d[key]
						if key == "bert.cls.predictions.decoder.weight":
									# Old bert code didn't have `decoder.bias`, but was added separately
									lowerCamelCase__	:	Optional[Any]				=new_d['''cls.predictions.bias''']
			return new_d






@torch.no_grad()
def   snake_case__     (	__lowerCamelCase       :					Tuple							,	__lowerCamelCase       :					Union[str, Any]			):
			"""simple docstring"""
			assert (
			    checkpoint_path.split('''/'''			)[-1] in ACCEPTABLE_CHECKPOINTS
			), f'''The checkpoint provided must be in {ACCEPTABLE_CHECKPOINTS}.'''

			# Get Config
			if "pre" in checkpoint_path:
						lowerCamelCase__	:	Dict				='''pretraining'''
						if "vcr" in checkpoint_path:
									lowerCamelCase__	:	str				={'''visual_embedding_dim''': 512}
						elif "vqa_advanced" in checkpoint_path:
									lowerCamelCase__	:	int				={'''visual_embedding_dim''': 2048}
						elif "vqa" in checkpoint_path:
									lowerCamelCase__	:	int				={'''visual_embedding_dim''': 2048}
						elif "nlvr" in checkpoint_path:
									lowerCamelCase__	:	Union[str, Any]				={'''visual_embedding_dim''': 1024}
						else:
									raise NotImplementedError(f'''No implementation found for `{checkpoint_path}`.'''			)
			else:
						if "vcr" in checkpoint_path:
									lowerCamelCase__	:	Union[str, Any]				={'''visual_embedding_dim''': 512}
									lowerCamelCase__	:	List[str]				='''multichoice'''
						elif "vqa_advanced" in checkpoint_path:
									lowerCamelCase__	:	List[Any]				={'''visual_embedding_dim''': 2048}
									lowerCamelCase__	:	List[Any]				='''vqa_advanced'''
						elif "vqa" in checkpoint_path:
									lowerCamelCase__	:	Any				={'''visual_embedding_dim''': 2048, '''num_labels''': 3129}
									lowerCamelCase__	:	Optional[Any]				='''vqa'''
						elif "nlvr" in checkpoint_path:
									lowerCamelCase__	:	List[str]				={
									    '''visual_embedding_dim''': 1024,
									    '''num_labels''': 2,
									}
									lowerCamelCase__	:	Any				='''nlvr'''

			lowerCamelCase__	:	Tuple				=VisualBertConfig(**__lowerCamelCase			)

			# Load State Dict
			lowerCamelCase__	:	Any				=load_state_dict(__lowerCamelCase			)

			lowerCamelCase__	:	Any				=get_new_dict(__lowerCamelCase							,	__lowerCamelCase			)

			if model_type == "pretraining":
						lowerCamelCase__	:	int				=VisualBertForPreTraining(__lowerCamelCase			)
			elif model_type == "vqa":
						lowerCamelCase__	:	Optional[int]				=VisualBertForQuestionAnswering(__lowerCamelCase			)
			elif model_type == "nlvr":
						lowerCamelCase__	:	str				=VisualBertForVisualReasoning(__lowerCamelCase			)
			elif model_type == "multichoice":
						lowerCamelCase__	:	Tuple				=VisualBertForMultipleChoice(__lowerCamelCase			)

			model.load_state_dict(__lowerCamelCase			)
			# Save Checkpoints
			Path(__lowerCamelCase			).mkdir(exist_ok=__lowerCamelCase			)
			model.save_pretrained(__lowerCamelCase			)


if __name__ == "__main__":
		_lowercase				:				List[str]   		=		argparse.ArgumentParser()
		# Required parameters
		parser.add_argument("orig_checkpoint_path", type=str, help="A path to .th on local filesystem.")
		parser.add_argument("pytorch_dump_folder_path", type=str, help="Path to the output PyTorch model.")
		_lowercase				:				Optional[int]   		=		parser.parse_args()
		convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)









"""simple docstring"""






def   snake_case__     (	__lowerCamelCase       :					int = 10							,	__lowerCamelCase       :					int = 22			):
			"""simple docstring"""
			lowerCamelCase__	:	Optional[Any]				=range(1							,	__lowerCamelCase			)
			lowerCamelCase__	:	str				=range(1							,	__lowerCamelCase			)
			return sum(
			    1 for power in powers for base in bases if len(str(base**power			)			) == power			)


if __name__ == "__main__":
		print(f'{solution(1_0, 2_2) = }')




