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()
__a    :	Optional[Any]         =    logging.get_logger(__name__)

__a    :	str         =    [
    ("""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"""),
]

__a    :	List[str]         =    [
    """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 							UpperCAmelCase		(       lowercase				):







				"""simple docstring"""



				__lowercase					     =				torch.load(lowercase				,     map_location='''cpu'''				)
				return sd





def 							UpperCAmelCase		(       lowercase				,     lowercase				,     lowercase=rename_keys_prefix				):







				"""simple docstring"""



				__lowercase					     =				OrderedDict()
				__lowercase					     =				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
								__lowercase					     =				key
								for name_pair in rename_keys_prefix:
												__lowercase					     =				new_key.replace(name_pair[0]				,     name_pair[1]				)
								__lowercase					     =				d[key]
								if key == "bert.cls.predictions.decoder.weight":
												# Old bert code didn't have `decoder.bias`, but was added separately
												__lowercase					     =				new_d['''cls.predictions.bias''']
				return new_d





@torch.no_grad()
def 							UpperCAmelCase		(       lowercase				,     lowercase				):







				"""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:
								__lowercase					     =				'''pretraining'''
								if "vcr" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 512}
								elif "vqa_advanced" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 2048}
								elif "vqa" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 2048}
								elif "nlvr" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 1024}
								else:
												raise NotImplementedError(F"No implementation found for `{checkpoint_path}`."				)
				else:
								if "vcr" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 512}
												__lowercase					     =				'''multichoice'''
								elif "vqa_advanced" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 2048}
												__lowercase					     =				'''vqa_advanced'''
								elif "vqa" in checkpoint_path:
												__lowercase					     =				{'''visual_embedding_dim''': 2048, '''num_labels''': 3129}
												__lowercase					     =				'''vqa'''
								elif "nlvr" in checkpoint_path:
												__lowercase					     =				{
												    '''visual_embedding_dim''': 1024,
												    '''num_labels''': 2,
												}
												__lowercase					     =				'''nlvr'''

				__lowercase					     =				VisualBertConfig(**lowercase				)

				# Load State Dict
				__lowercase					     =				load_state_dict(lowercase				)

				__lowercase					     =				get_new_dict(lowercase				,     lowercase				)

				if model_type == "pretraining":
								__lowercase					     =				VisualBertForPreTraining(lowercase				)
				elif model_type == "vqa":
								__lowercase					     =				VisualBertForQuestionAnswering(lowercase				)
				elif model_type == "nlvr":
								__lowercase					     =				VisualBertForVisualReasoning(lowercase				)
				elif model_type == "multichoice":
								__lowercase					     =				VisualBertForMultipleChoice(lowercase				)

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


if __name__ == "__main__":
		__a    :	Union[str, Any]         =    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.""")
		__a    :	Union[str, Any]         =    parser.parse_args()
		convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)
def 							UpperCAmelCase		(       lowercase				):







				"""simple docstring"""



				if not isinstance(lowercase				,     lowercase				):
								raise ValueError('''Input must be an integer'''				)
				if input_num <= 0:
								raise ValueError('''Input must be positive'''				)
				return sum(
				    divisor for divisor in range(1				,     input_num // 2 + 1				) if input_num % divisor == 0				)


if __name__ == "__main__":
		import doctest

		doctest.testmod()