




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

a													=			[
    ("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													=			[
    "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        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				Any:
						_UpperCAmelCase      =			torch.load(snake_case			,     map_location="""cpu"""       )
						return sd




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




@torch.no_grad()
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				Dict:
						assert (
						    checkpoint_path.split("""/"""       )[-1] in ACCEPTABLE_CHECKPOINTS
						), f"The checkpoint provided must be in {ACCEPTABLE_CHECKPOINTS}."

						# Get Config
						if "pre" in checkpoint_path:
												_UpperCAmelCase      =			"""pretraining"""
												if "vcr" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 5_1_2}
												elif "vqa_advanced" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 2_0_4_8}
												elif "vqa" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 2_0_4_8}
												elif "nlvr" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 1_0_2_4}
												else:
																		raise NotImplementedError(f"No implementation found for `{checkpoint_path}`."       )
						else:
												if "vcr" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 5_1_2}
																		_UpperCAmelCase      =			"""multichoice"""
												elif "vqa_advanced" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 2_0_4_8}
																		_UpperCAmelCase      =			"""vqa_advanced"""
												elif "vqa" in checkpoint_path:
																		_UpperCAmelCase      =			{"""visual_embedding_dim""": 2_0_4_8, """num_labels""": 3_1_2_9}
																		_UpperCAmelCase      =			"""vqa"""
												elif "nlvr" in checkpoint_path:
																		_UpperCAmelCase      =			{
																		    """visual_embedding_dim""": 1_0_2_4,
																		    """num_labels""": 2,
																		}
																		_UpperCAmelCase      =			"""nlvr"""

						_UpperCAmelCase      =			VisualBertConfig(**snake_case       )

						# Load State Dict
						_UpperCAmelCase      =			load_state_dict(snake_case       )

						_UpperCAmelCase      =			get_new_dict(snake_case			,     snake_case       )

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

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


if __name__ == "__main__":
				a													=			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													=			parser.parse_args()
				convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)





import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				int:
						assert isinstance(snake_case			,     snake_case       )
						assert dataset.num_rows == 4
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_1", "col_2", "col_3"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype




@pytest.mark.parametrize("""keep_in_memory"""			,     [False, True]       )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				Optional[int]:
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     cache_dir=snake_case			,     keep_in_memory=snake_case       ).read()
						_check_json_dataset(snake_case			,     snake_case       )




@pytest.mark.parametrize(
    """features"""			,     [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]			,     )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				Optional[Any]:
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						_UpperCAmelCase      =			features.copy() if features else default_expected_features
						_UpperCAmelCase      =			(
						    Features({feature: Value(snake_case       ) for feature, dtype in features.items()}       ) if features is not None else None
						)
						_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     features=snake_case			,     cache_dir=snake_case       ).read()
						_check_json_dataset(snake_case			,     snake_case       )




@pytest.mark.parametrize(
    """features"""			,     [
        None,
        {"""col_3""": """float64""", """col_1""": """string""", """col_2""": """int64"""},
    ]			,     )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				int:
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_3""": """float64""", """col_1""": """string""", """col_2""": """int64"""}
						_UpperCAmelCase      =			features.copy() if features else default_expected_features
						_UpperCAmelCase      =			(
						    Features({feature: Value(snake_case       ) for feature, dtype in features.items()}       ) if features is not None else None
						)
						_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     features=snake_case			,     cache_dir=snake_case       ).read()
						assert isinstance(snake_case			,     snake_case       )
						assert dataset.num_rows == 2
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_3", "col_1", "col_2"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				Optional[int]:
						# jsonl_312_path features are {"col_3": "float64", "col_1": "string", "col_2": "int64"}
						_UpperCAmelCase      =			{"""col_2""": """int64""", """col_3""": """float64""", """col_1""": """string"""}
						_UpperCAmelCase      =			features.copy()
						_UpperCAmelCase      =			(
						    Features({feature: Value(snake_case       ) for feature, dtype in features.items()}       ) if features is not None else None
						)
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     features=snake_case			,     cache_dir=snake_case       ).read()
						assert isinstance(snake_case			,     snake_case       )
						assert dataset.num_rows == 2
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_2", "col_3", "col_1"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype




@pytest.mark.parametrize("""split"""			,     [None, NamedSplit("""train"""       ), """train""", """test"""]       )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				List[Any]:
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     cache_dir=snake_case			,     split=snake_case       ).read()
						_check_json_dataset(snake_case			,     snake_case       )
						assert dataset.split == split if split else "train"




@pytest.mark.parametrize("""path_type"""			,     [str, list]       )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				Any:
						if issubclass(snake_case			,     snake_case       ):
												_UpperCAmelCase      =			jsonl_path
						elif issubclass(snake_case			,     snake_case       ):
												_UpperCAmelCase      =			[jsonl_path]
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     cache_dir=snake_case       ).read()
						_check_json_dataset(snake_case			,     snake_case       )




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case=("train",)       )						->				str:
						assert isinstance(snake_case			,     snake_case       )
						for split in splits:
												_UpperCAmelCase      =			dataset_dict[split]
												assert dataset.num_rows == 4
												assert dataset.num_columns == 3
												assert dataset.column_names == ["col_1", "col_2", "col_3"]
												for feature, expected_dtype in expected_features.items():
																		assert dataset.features[feature].dtype == expected_dtype




@pytest.mark.parametrize("""keep_in_memory"""			,     [False, True]       )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				str:
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												_UpperCAmelCase      =			JsonDatasetReader({"""train""": jsonl_path}			,     cache_dir=snake_case			,     keep_in_memory=snake_case       ).read()
						_check_json_datasetdict(snake_case			,     snake_case       )




@pytest.mark.parametrize(
    """features"""			,     [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]			,     )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				Tuple:
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						_UpperCAmelCase      =			features.copy() if features else default_expected_features
						_UpperCAmelCase      =			(
						    Features({feature: Value(snake_case       ) for feature, dtype in features.items()}       ) if features is not None else None
						)
						_UpperCAmelCase      =			JsonDatasetReader({"""train""": jsonl_path}			,     features=snake_case			,     cache_dir=snake_case       ).read()
						_check_json_datasetdict(snake_case			,     snake_case       )




@pytest.mark.parametrize("""split"""			,     [None, NamedSplit("""train"""       ), """train""", """test"""]       )
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				Optional[Any]:
						if split:
												_UpperCAmelCase      =			{split: jsonl_path}
						else:
												_UpperCAmelCase      =			"""train"""
												_UpperCAmelCase      =			{"""train""": jsonl_path, """test""": jsonl_path}
						_UpperCAmelCase      =			tmp_path / """cache"""
						_UpperCAmelCase      =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						_UpperCAmelCase      =			JsonDatasetReader(snake_case			,     cache_dir=snake_case       ).read()
						_check_json_datasetdict(snake_case			,     snake_case			,     splits=list(path.keys()       )       )
						assert all(dataset[split].split == split for split in path.keys()       )




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				List[Any]:
						return json.load(snake_case       )




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				List[Any]:
						return [json.loads(snake_case       ) for line in buffer]




class       _A				:






		@pytest.mark.parametrize("""lines, load_json_function"""						,		[(True, load_json_lines), (False, load_json)]			)
		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		lines=_SCREAMING_SNAKE_CASE			).write()
														buffer.seek(0			)
														_UpperCAmelCase      =			load_json_function(_SCREAMING_SNAKE_CASE			)
								assert isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)
								assert isinstance(exported_content[0]						,		_SCREAMING_SNAKE_CASE			)
								assert len(_SCREAMING_SNAKE_CASE			) == 10






		@pytest.mark.parametrize(
		    """orient, container, keys, len_at"""						,		[
		        ("""records""", list, {"""tokens""", """labels""", """answers""", """id"""}, None),
		        ("""split""", dict, {"""columns""", """data"""}, """data"""),
		        ("""index""", dict, set("""0123456789"""			), None),
		        ("""columns""", dict, {"""tokens""", """labels""", """answers""", """id"""}, """tokens"""),
		        ("""values""", list, None, None),
		        ("""table""", dict, {"""schema""", """data"""}, """data"""),
		    ]						,		)
		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		lines=_SCREAMING_SNAKE_CASE						,		orient=_SCREAMING_SNAKE_CASE			).write()
														buffer.seek(0			)
														_UpperCAmelCase      =			load_json(_SCREAMING_SNAKE_CASE			)
								assert isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)
								if keys:
														if container is dict:
																				assert exported_content.keys() == keys
														else:
																				assert exported_content[0].keys() == keys
								else:
														assert not hasattr(_SCREAMING_SNAKE_CASE						,		"""keys"""			) and not hasattr(exported_content[0]						,		"""keys"""			)
								if len_at:
														assert len(exported_content[len_at]			) == 10
								else:
														assert len(_SCREAMING_SNAKE_CASE			) == 10






		@pytest.mark.parametrize("""lines, load_json_function"""						,		[(True, load_json_lines), (False, load_json)]			)
		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		lines=_SCREAMING_SNAKE_CASE						,		num_proc=2			).write()
														buffer.seek(0			)
														_UpperCAmelCase      =			load_json_function(_SCREAMING_SNAKE_CASE			)
								assert isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)
								assert isinstance(exported_content[0]						,		_SCREAMING_SNAKE_CASE			)
								assert len(_SCREAMING_SNAKE_CASE			) == 10






		@pytest.mark.parametrize(
		    """orient, container, keys, len_at"""						,		[
		        ("""records""", list, {"""tokens""", """labels""", """answers""", """id"""}, None),
		        ("""split""", dict, {"""columns""", """data"""}, """data"""),
		        ("""index""", dict, set("""0123456789"""			), None),
		        ("""columns""", dict, {"""tokens""", """labels""", """answers""", """id"""}, """tokens"""),
		        ("""values""", list, None, None),
		        ("""table""", dict, {"""schema""", """data"""}, """data"""),
		    ]						,		)
		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		lines=_SCREAMING_SNAKE_CASE						,		orient=_SCREAMING_SNAKE_CASE						,		num_proc=2			).write()
														buffer.seek(0			)
														_UpperCAmelCase      =			load_json(_SCREAMING_SNAKE_CASE			)
								assert isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)
								if keys:
														if container is dict:
																				assert exported_content.keys() == keys
														else:
																				assert exported_content[0].keys() == keys
								else:
														assert not hasattr(_SCREAMING_SNAKE_CASE						,		"""keys"""			) and not hasattr(exported_content[0]						,		"""keys"""			)
								if len_at:
														assert len(exported_content[len_at]			) == 10
								else:
														assert len(_SCREAMING_SNAKE_CASE			) == 10






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE			):
								with pytest.raises(_SCREAMING_SNAKE_CASE			):
														with io.BytesIO() as buffer:
																				JsonDatasetWriter(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		num_proc=0			)






		@pytest.mark.parametrize("""compression, extension"""						,		[("""gzip""", """gz"""), ("""bz2""", """bz2"""), ("""xz""", """xz""")]			)
		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
								_UpperCAmelCase      =			tmp_path_factory.mktemp("""data"""			) / F"test.json.{extension}"
								_UpperCAmelCase      =			str(shared_datadir / F"test_file.json.{extension}"			)
								JsonDatasetWriter(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		compression=_SCREAMING_SNAKE_CASE			).write()

								with fsspec.open(_SCREAMING_SNAKE_CASE						,		"""rb"""						,		compression="""infer"""			) as f:
														_UpperCAmelCase      =			f.read()
								with fsspec.open(_SCREAMING_SNAKE_CASE						,		"""rb"""						,		compression="""infer"""			) as f:
														_UpperCAmelCase      =			f.read()
								assert exported_content == original_content