






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

A__	:			Optional[int]			   = [
    ('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__	:			Optional[int]			   = [
    '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   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			torch.load(__A		,   map_location='''cpu'''				)
				return sd






def   a			(						lowerCamelCase_		,   lowerCamelCase_		,   lowerCamelCase_=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   a			(						lowerCamelCase_		,   lowerCamelCase_				):






				'''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(**__A				)

				# Load State Dict
				lowercase__    =			load_state_dict(__A				)

				lowercase__    =			get_new_dict(__A		,   __A				)

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

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


if __name__ == "__main__":
							A__	:			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.')
							A__	:			List[Any]			   = parser.parse_args()
							convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)








import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class  SCREAMING_SNAKE_CASE__  (				lowercase__						,    unittest.TestCase			):
      snake_case__				:     Any        =						GPTSanJapaneseTokenizer
      snake_case__				:     Tuple        =						False
      snake_case__				:     str        =						{'''do_clean_text''': False, '''add_prefix_space''': False}
      def        SCREAMING_SNAKE_CASE							(       self				:       List[Any]     )		->			str:
             super().setUp()

             # fmt: off
             a_					:		Union[str, Any]							=  ['こん', 'こんに', 'にちは', 'ばんは', '世界,㔺界', '、', '。', '<BR>', '<SP>', '<TAB>', '<URL>', '<EMAIL>', '<TEL>', '<DATE>', '<PRICE>', '<BLOCK>', '<KIGOU>', '<U2000U2BFF>', '<|emoji1|>', '<unk>', '<|bagoftoken|>', '<|endoftext|>']
             # fmt: on
             a_					:		int							=  {'emoji': {'\ud83d\ude00': '<|emoji1|>'}, 'emoji_inv': {'<|emoji1|>': '\ud83d\ude00'}}  # 😀
             a_					:		List[Any]							=  {'unk_token': '<unk>'}

             a_					:		Any							=  os.path.join(self.tmpdirname     ,							VOCAB_FILES_NAMES['vocab_file']     )
             a_					:		List[str]							=  os.path.join(self.tmpdirname     ,							VOCAB_FILES_NAMES['emoji_file']     )
             with open(self.vocab_file     ,							'w'     ,							encoding='utf-8'     ) as vocab_writer:
                    vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]     )     )
             with open(self.emoji_file     ,							'w'     ) as emoji_writer:
                    emoji_writer.write(json.dumps(SCREAMING_SNAKE_CASE__     )     )
      def        SCREAMING_SNAKE_CASE							(       self				:       List[str]     ,							**SCREAMING_SNAKE_CASE__				:       Tuple     )		->			int:
             kwargs.update(self.special_tokens_map     )
             return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname     ,							**SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]     )		->			int:
             a_					:		Optional[int]							=  'こんにちは、世界。 \nこんばんは、㔺界。😀'
             a_					:		List[str]							=  'こんにちは、世界。 \nこんばんは、世界。😀'
             return input_text, output_text
      def        SCREAMING_SNAKE_CASE							(       self				:       str     ,							SCREAMING_SNAKE_CASE__				:       int     )		->			Dict:
             a_							,		a_					:		Union[str, Any]							=  self.get_input_output_texts(SCREAMING_SNAKE_CASE__     )
             a_					:		List[Any]							=  tokenizer.encode(SCREAMING_SNAKE_CASE__     ,							add_special_tokens=SCREAMING_SNAKE_CASE__     )
             a_					:		Dict							=  tokenizer.decode(SCREAMING_SNAKE_CASE__     ,							clean_up_tokenization_spaces=SCREAMING_SNAKE_CASE__     )
             return text, ids
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			int:
             pass  # TODO add if relevant
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			Any:
             pass  # TODO add if relevant
      def        SCREAMING_SNAKE_CASE							(       self				:       Any     )		->			Tuple:
             pass  # TODO add if relevant
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			List[str]:
             a_					:		List[str]							=  self.get_tokenizer()

             # Testing tokenization
             a_					:		List[Any]							=  'こんにちは、世界。　こんばんは、㔺界。'
             a_					:		Optional[int]							=  ['こん', 'にちは', '、', '世界', '。', '<SP>', 'こん', 'ばんは', '、', '㔺界', '。']
             a_					:		Dict							=  tokenizer.tokenize(SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )

             # Testing conversion to ids without special tokens
             a_					:		Tuple							=  [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
             a_					:		List[Any]							=  tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )

             # Testing conversion to ids with special tokens
             a_					:		int							=  tokens + [tokenizer.unk_token]
             a_					:		int							=  [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 1_9]
             a_					:		Tuple							=  tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       List[str]     )		->			Dict:
             a_					:		Union[str, Any]							=  self.get_tokenizer()

             # Testing tokenization
             a_					:		Dict							=  'こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'
             a_					:		List[Any]							=  'こんにちは、、、、世界。こんばんは、、、、世界。'
             a_					:		Any							=  tokenizer.encode(SCREAMING_SNAKE_CASE__     )
             a_					:		Optional[Any]							=  tokenizer.decode(SCREAMING_SNAKE_CASE__     )
             self.assertEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
      @slow
      def        SCREAMING_SNAKE_CASE							(       self				:       str     )		->			Dict:
             a_					:		Tuple							=  self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'     )

             # Testing tokenization
             a_					:		List[Any]							=  'こんにちは、世界。'
             a_					:		int							=  'こんばんは、㔺界。😀'
             a_					:		Dict							=  'こんにちは、世界。こんばんは、世界。😀'
             a_					:		Optional[int]							=  tokenizer.encode(prefix_text + input_text     )
             a_					:		Any							=  tokenizer.encode(''     ,							prefix_text=prefix_text + input_text     )
             a_					:		Union[str, Any]							=  tokenizer.encode(SCREAMING_SNAKE_CASE__     ,							prefix_text=SCREAMING_SNAKE_CASE__     )
             a_					:		List[Any]							=  tokenizer.decode(SCREAMING_SNAKE_CASE__     )
             a_					:		Tuple							=  tokenizer.decode(SCREAMING_SNAKE_CASE__     )
             a_					:		str							=  tokenizer.decode(SCREAMING_SNAKE_CASE__     )
             self.assertEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
             self.assertEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
             self.assertEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
      @slow
      def        SCREAMING_SNAKE_CASE							(       self				:       Optional[int]     )		->			Optional[int]:
             a_					:		Tuple							=  self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'     )

             # Testing tokenization
             a_					:		str							=  'こんにちは、世界。'
             a_					:		List[str]							=  'こんばんは、㔺界。😀'

             a_					:		str							=  len(tokenizer.encode(SCREAMING_SNAKE_CASE__     )     ) - 2
             a_					:		Tuple							=  len(tokenizer.encode(SCREAMING_SNAKE_CASE__     )     ) - 2

             a_					:		Optional[Any]							=  [1] + [0] * (len_prefix + len_text + 1)
             a_					:		Optional[Any]							=  [1] * (len_prefix + len_text + 1) + [0]
             a_					:		Tuple							=  [1] + [1] * (len_prefix) + [0] * (len_text + 1)

             a_					:		List[str]							=  tokenizer(prefix_text + input_text     ).token_type_ids
             a_					:		Union[str, Any]							=  tokenizer(''     ,							prefix_text=prefix_text + input_text     ).token_type_ids
             a_					:		Any							=  tokenizer(SCREAMING_SNAKE_CASE__     ,							prefix_text=SCREAMING_SNAKE_CASE__     ).token_type_ids
             self.assertListEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
      @slow
      def        SCREAMING_SNAKE_CASE							(       self				:       Union[str, Any]     )		->			int:
             a_					:		str							=  self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'     )

             a_					:		Optional[int]							=  tokenizer.encode('あンいワ'     )
             a_					:		Dict							=  tokenizer.encode(''     ,							prefix_text='あンいワ'     )
             a_					:		Dict							=  tokenizer.encode('いワ'     ,							prefix_text='あン'     )

             self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE__     )     ,							tokenizer.decode(SCREAMING_SNAKE_CASE__     )     )
             self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE__     )     ,							tokenizer.decode(SCREAMING_SNAKE_CASE__     )     )
             self.assertNotEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
             self.assertNotEqual(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     )
             self.assertEqual(x_token_a[1]     ,							x_token_a[-1]     )  # SEG token
             self.assertEqual(x_token_a[1]     ,							x_token_a[3]     )  # SEG token
      @slow
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			Optional[Any]:
             a_					:		List[str]							=  self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'     )

             a_					:		Optional[Any]							=  [['武田信玄', 'は、'], ['織田信長', 'の配下の、']]
             a_					:		List[str]							=  tokenizer(SCREAMING_SNAKE_CASE__     ,							padding=SCREAMING_SNAKE_CASE__     )
             a_					:		Dict							=  tokenizer.batch_encode_plus(SCREAMING_SNAKE_CASE__     ,							padding=SCREAMING_SNAKE_CASE__     )

             # fmt: off
             a_					:		List[Any]							=  [[3_5_9_9_3, 8_6_4_0, 2_5_9_4_8, 3_5_9_9_8, 3_0_6_4_7, 3_5_6_7_5, 3_5_9_9_9, 3_5_9_9_9], [3_5_9_9_3, 1_0_3_8_2, 9_8_6_8, 3_5_9_9_8, 3_0_6_4_6, 9_4_5_9, 3_0_6_4_6, 3_5_6_7_5]]
             a_					:		Any							=  [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
             a_					:		List[Any]							=  [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
             # fmt: on
             self.assertListEqual(x_token.input_ids     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(x_token.token_type_ids     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(x_token.attention_mask     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(x_token_a.input_ids     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(x_token_a.token_type_ids     ,							SCREAMING_SNAKE_CASE__     )
             self.assertListEqual(x_token_a.attention_mask     ,							SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Tuple     )		->			Dict:
             # Intentionally convert some words to accommodate character fluctuations unique to Japanese
             pass

      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			int:
             # tokenizer has no padding token
             pass


