


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

a			:			List[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[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 		lowercase_	(  _UpperCamelCase	):


			'''simple docstring'''







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


def 		lowercase_	(  _UpperCamelCase							,      _UpperCamelCase							,      _UpperCamelCase=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 		lowercase_	(  _UpperCamelCase							,      _UpperCamelCase	):


			'''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''': 5_12}
						elif "vqa_advanced" in checkpoint_path:
									__lowercase			       = {'''visual_embedding_dim''': 20_48}
						elif "vqa" in checkpoint_path:
									__lowercase			       = {'''visual_embedding_dim''': 20_48}
						elif "nlvr" in checkpoint_path:
									__lowercase			       = {'''visual_embedding_dim''': 10_24}
						else:
									raise NotImplementedError(F'No implementation found for `{checkpoint_path}`.'	)
			else:
						if "vcr" in checkpoint_path:
									__lowercase			       = {'''visual_embedding_dim''': 5_12}
									__lowercase			       = '''multichoice'''
						elif "vqa_advanced" in checkpoint_path:
									__lowercase			       = {'''visual_embedding_dim''': 20_48}
									__lowercase			       = '''vqa_advanced'''
						elif "vqa" in checkpoint_path:
									__lowercase			       = {'''visual_embedding_dim''': 20_48, '''num_labels''': 31_29}
									__lowercase			       = '''vqa'''
						elif "nlvr" in checkpoint_path:
									__lowercase			       = {
									    '''visual_embedding_dim''': 10_24,
									    '''num_labels''': 2,
									}
									__lowercase			       = '''nlvr'''

			__lowercase			       = VisualBertConfig(**_UpperCamelCase	)

			# Load State Dict
			__lowercase			       = load_state_dict(_UpperCamelCase	)

			__lowercase			       = get_new_dict(_UpperCamelCase							,      _UpperCamelCase	)

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

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


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			:			List[str]												=					parser.parse_args()
	convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)






import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate
@dataclass(frozen=lowerCAmelCase__					)
class 						lowerCamelCase_							(					lowerCAmelCase__					):



					'''simple docstring'''







					__UpperCAmelCase							  =					field(default="automatic-speech-recognition"  ,  metadata={"include_in_asdict_even_if_is_default": True}					)
					__UpperCAmelCase							  =					Features({"audio": Audio()}					)
					__UpperCAmelCase							  =					Features({"transcription": Value("string"					)}					)
					__UpperCAmelCase							  =					"audio"
					__UpperCAmelCase							  =					"transcription"






					def A   (					self			,							snake_case_    ) ->      Any:







								'''simple docstring'''

								if self.audio_column not in features:
											raise ValueError(F'Column {self.audio_column} is not present in features.'    )
								if not isinstance(features[self.audio_column]			,							snake_case_    ):
											raise ValueError(F'Column {self.audio_column} is not an Audio type.'    )
								__lowercase			       = copy.deepcopy(self    )
								__lowercase			       = self.input_schema.copy()
								__lowercase			       = features[self.audio_column]
								__lowercase			       = input_schema
								return task_template






					@property
					def A   (					self    ) ->      Dict[str, str]:







								'''simple docstring'''

								return {self.audio_column: "audio", self.transcription_column: "transcription"}


