




'''simple docstring'''


import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_snake_case : List[Any]  				=						logging.get_logger(__name__)
def 						snake_case_       (UpperCamelCase			:    Optional[int]					,		UpperCamelCase			:    Dict=False					,		UpperCamelCase			:    str=False					,		UpperCamelCase			:    str=False ):





							'''simple docstring'''


							_a      	=							[]
							for i in range(config.num_hidden_layers ):
														# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
														rename_keys.append((f'transformer.blocks.{i}.norm1.weight', f'vilt.encoder.layer.{i}.layernorm_before.weight') )
														rename_keys.append((f'transformer.blocks.{i}.norm1.bias', f'vilt.encoder.layer.{i}.layernorm_before.bias') )
														rename_keys.append(
														    (f'transformer.blocks.{i}.attn.proj.weight', f'vilt.encoder.layer.{i}.attention.output.dense.weight') )
														rename_keys.append(
														    (f'transformer.blocks.{i}.attn.proj.bias', f'vilt.encoder.layer.{i}.attention.output.dense.bias') )
														rename_keys.append((f'transformer.blocks.{i}.norm2.weight', f'vilt.encoder.layer.{i}.layernorm_after.weight') )
														rename_keys.append((f'transformer.blocks.{i}.norm2.bias', f'vilt.encoder.layer.{i}.layernorm_after.bias') )
														rename_keys.append(
														    (f'transformer.blocks.{i}.mlp.fc1.weight', f'vilt.encoder.layer.{i}.intermediate.dense.weight') )
														rename_keys.append((f'transformer.blocks.{i}.mlp.fc1.bias', f'vilt.encoder.layer.{i}.intermediate.dense.bias') )
														rename_keys.append((f'transformer.blocks.{i}.mlp.fc2.weight', f'vilt.encoder.layer.{i}.output.dense.weight') )
														rename_keys.append((f'transformer.blocks.{i}.mlp.fc2.bias', f'vilt.encoder.layer.{i}.output.dense.bias') )

							# embeddings
							rename_keys.extend(
							    [
							        # text embeddings
							        ('''text_embeddings.word_embeddings.weight''', '''vilt.embeddings.text_embeddings.word_embeddings.weight'''),
							        (
							            '''text_embeddings.position_embeddings.weight''',
							            '''vilt.embeddings.text_embeddings.position_embeddings.weight''',
							        ),
							        ('''text_embeddings.position_ids''', '''vilt.embeddings.text_embeddings.position_ids'''),
							        (
							            '''text_embeddings.token_type_embeddings.weight''',
							            '''vilt.embeddings.text_embeddings.token_type_embeddings.weight''',
							        ),
							        ('''text_embeddings.LayerNorm.weight''', '''vilt.embeddings.text_embeddings.LayerNorm.weight'''),
							        ('''text_embeddings.LayerNorm.bias''', '''vilt.embeddings.text_embeddings.LayerNorm.bias'''),
							        # patch embeddings
							        ('''transformer.cls_token''', '''vilt.embeddings.cls_token'''),
							        ('''transformer.patch_embed.proj.weight''', '''vilt.embeddings.patch_embeddings.projection.weight'''),
							        ('''transformer.patch_embed.proj.bias''', '''vilt.embeddings.patch_embeddings.projection.bias'''),
							        ('''transformer.pos_embed''', '''vilt.embeddings.position_embeddings'''),
							        # token type embeddings
							        ('''token_type_embeddings.weight''', '''vilt.embeddings.token_type_embeddings.weight'''),
							    ] )

							# final layernorm + pooler
							rename_keys.extend(
							    [
							        ('''transformer.norm.weight''', '''vilt.layernorm.weight'''),
							        ('''transformer.norm.bias''', '''vilt.layernorm.bias'''),
							        ('''pooler.dense.weight''', '''vilt.pooler.dense.weight'''),
							        ('''pooler.dense.bias''', '''vilt.pooler.dense.bias'''),
							    ] )

							# classifier head(s)
							if vqa_model:
														# classification head
														rename_keys.extend(
														    [
														        ('''vqa_classifier.0.weight''', '''classifier.0.weight'''),
														        ('''vqa_classifier.0.bias''', '''classifier.0.bias'''),
														        ('''vqa_classifier.1.weight''', '''classifier.1.weight'''),
														        ('''vqa_classifier.1.bias''', '''classifier.1.bias'''),
														        ('''vqa_classifier.3.weight''', '''classifier.3.weight'''),
														        ('''vqa_classifier.3.bias''', '''classifier.3.bias'''),
														    ] )
							elif nlvr_model:
														# classification head
														rename_keys.extend(
														    [
														        ('''nlvr2_classifier.0.weight''', '''classifier.0.weight'''),
														        ('''nlvr2_classifier.0.bias''', '''classifier.0.bias'''),
														        ('''nlvr2_classifier.1.weight''', '''classifier.1.weight'''),
														        ('''nlvr2_classifier.1.bias''', '''classifier.1.bias'''),
														        ('''nlvr2_classifier.3.weight''', '''classifier.3.weight'''),
														        ('''nlvr2_classifier.3.bias''', '''classifier.3.bias'''),
														    ] )
							else:
														pass

							return rename_keys
def 						snake_case_       (UpperCamelCase			:    Union[str, Any]					,		UpperCamelCase			:    Dict ):





							'''simple docstring'''


							for i in range(config.num_hidden_layers ):
														_a      	=							'''vilt.'''
														# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
														_a      	=							state_dict.pop(f'transformer.blocks.{i}.attn.qkv.weight' )
														_a      	=							state_dict.pop(f'transformer.blocks.{i}.attn.qkv.bias' )
														# next, add query, keys and values (in that order) to the state dict
														_a      	=							in_proj_weight[
														    : config.hidden_size, :
														]
														_a      	=							in_proj_bias[: config.hidden_size]
														_a      	=							in_proj_weight[
														    config.hidden_size : config.hidden_size * 2, :
														]
														_a      	=							in_proj_bias[
														    config.hidden_size : config.hidden_size * 2
														]
														_a      	=							in_proj_weight[
														    -config.hidden_size :, :
														]
														_a      	=							in_proj_bias[-config.hidden_size :]
def 						snake_case_       (UpperCamelCase			:    Optional[int] ):





							'''simple docstring'''


							_a      	=							['''head.weight''', '''head.bias''']
							for k in ignore_keys:
														state_dict.pop(UpperCamelCase					,		UpperCamelCase )
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    Tuple					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							_a      	=							dct.pop(UpperCamelCase )
							_a      	=							val
@torch.no_grad()
def 						snake_case_       (UpperCamelCase			:    Dict					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							_a      	=							ViltConfig(image_size=384					,		patch_size=32					,		tie_word_embeddings=UpperCamelCase )
							_a      	=							False
							_a      	=							False
							_a      	=							False
							_a      	=							False
							if "vqa" in checkpoint_url:
														_a      	=							True
														_a      	=							3129
														_a      	=							'''huggingface/label-files'''
														_a      	=							'''vqa2-id2label.json'''
														_a      	=							json.load(open(hf_hub_download(UpperCamelCase					,		UpperCamelCase					,		repo_type='''dataset''' )					,		'''r''' ) )
														_a      	=							{int(UpperCamelCase ): v for k, v in idalabel.items()}
														_a      	=							idalabel
														_a      	=							{v: k for k, v in idalabel.items()}
														_a      	=							ViltForQuestionAnswering(UpperCamelCase )
							elif "nlvr" in checkpoint_url:
														_a      	=							True
														_a      	=							2
														_a      	=							{0: '''False''', 1: '''True'''}
														_a      	=							{v: k for k, v in config.idalabel.items()}
														_a      	=							3
														_a      	=							ViltForImagesAndTextClassification(UpperCamelCase )
							elif "irtr" in checkpoint_url:
														_a      	=							True
														_a      	=							ViltForImageAndTextRetrieval(UpperCamelCase )
							elif "mlm_itm" in checkpoint_url:
														_a      	=							True
														_a      	=							ViltForMaskedLM(UpperCamelCase )
							else:
														raise ValueError('''Unknown model type''' )

							# load state_dict of original model, remove and rename some keys
							_a      	=							torch.hub.load_state_dict_from_url(UpperCamelCase					,		map_location='''cpu''' )['''state_dict''']
							_a      	=							create_rename_keys(UpperCamelCase					,		UpperCamelCase					,		UpperCamelCase					,		UpperCamelCase )
							for src, dest in rename_keys:
														rename_key(UpperCamelCase					,		UpperCamelCase					,		UpperCamelCase )
							read_in_q_k_v(UpperCamelCase					,		UpperCamelCase )
							if mlm_model or irtr_model:
														_a      	=							['''itm_score.fc.weight''', '''itm_score.fc.bias''']
														for k in ignore_keys:
																					state_dict.pop(UpperCamelCase					,		UpperCamelCase )

    # load state dict into HuggingFace model
							model.eval()
							if mlm_model:
														_a	,				_a      	=							model.load_state_dict(UpperCamelCase					,		strict=UpperCamelCase )
														assert missing_keys == ["mlm_score.decoder.bias"]
							else:
														model.load_state_dict(UpperCamelCase )

							# Define processor
							_a      	=							ViltImageProcessor(size=384 )
							_a      	=							BertTokenizer.from_pretrained('''bert-base-uncased''' )
							_a      	=							ViltProcessor(UpperCamelCase					,		UpperCamelCase )

							# Forward pass on example inputs (image + text)
							if nlvr_model:
														_a      	=							Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'''					,		stream=UpperCamelCase ).raw )
														_a      	=							Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'''					,		stream=UpperCamelCase ).raw )
														_a      	=							(
														    '''The left image contains twice the number of dogs as the right image, and at least two dogs in total are'''
														    ''' standing.'''
														)
														_a      	=							processor(UpperCamelCase					,		UpperCamelCase					,		return_tensors='''pt''' )
														_a      	=							processor(UpperCamelCase					,		UpperCamelCase					,		return_tensors='''pt''' )
														_a      	=							model(
														    input_ids=encoding_a.input_ids					,		pixel_values=encoding_a.pixel_values					,		pixel_values_a=encoding_a.pixel_values					,		)
							else:
														_a      	=							Image.open(requests.get('''http://images.cocodataset.org/val2017/000000039769.jpg'''					,		stream=UpperCamelCase ).raw )
														if mlm_model:
																					_a      	=							'''a bunch of [MASK] laying on a [MASK].'''
														else:
																					_a      	=							'''How many cats are there?'''
														_a      	=							processor(UpperCamelCase					,		UpperCamelCase					,		return_tensors='''pt''' )
														_a      	=							model(**UpperCamelCase )

							# Verify outputs
							if mlm_model:
														_a      	=							torch.Size([1, 11, 3_0522] )
														_a      	=							torch.tensor([-12.5061, -12.5123, -12.5174] )
														assert outputs.logits.shape == expected_shape
														assert torch.allclose(outputs.logits[0, 0, :3]					,		UpperCamelCase					,		atol=1e-4 )

														# verify masked token prediction equals "cats"
														_a      	=							outputs.logits[0, 4, :].argmax(-1 ).item()
														assert tokenizer.decode([predicted_id] ) == "cats"
							elif vqa_model:
														_a      	=							torch.Size([1, 3129] )
														_a      	=							torch.tensor([-15.9495, -18.1472, -10.3041] )
														assert torch.allclose(outputs.logits[0, :3]					,		UpperCamelCase					,		atol=1e-4 )
														assert outputs.logits.shape == expected_shape
														assert torch.allclose(outputs.logits[0, 0, :3]					,		UpperCamelCase					,		atol=1e-4 )

														# verify vqa prediction equals "2"
														_a      	=							outputs.logits.argmax(-1 ).item()
														assert model.config.idalabel[predicted_idx] == "2"
							elif nlvr_model:
														_a      	=							torch.Size([1, 2] )
														_a      	=							torch.tensor([-2.8721, 2.1291] )
														assert torch.allclose(outputs.logits[0, :3]					,		UpperCamelCase					,		atol=1e-4 )
														assert outputs.logits.shape == expected_shape

							Path(UpperCamelCase ).mkdir(exist_ok=UpperCamelCase )
							print(f'Saving model and processor to {pytorch_dump_folder_path}' )
							model.save_pretrained(UpperCamelCase )
							processor.save_pretrained(UpperCamelCase )


if __name__ == "__main__":
				_snake_case : Union[str, Any]  				=						argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--checkpoint_url',
				    default='https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt',
				    type=str,
				    help='URL of the checkpoint you\'d like to convert.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
				)

				_snake_case : List[str]  				=						parser.parse_args()
				convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)







'''simple docstring'''


import json
import os
import unittest

from transformers import BatchEncoding, LEDTokenizer, LEDTokenizerFast
from transformers.models.led.tokenization_led import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class      A       (						_a	,unittest.TestCase       ):
							lowercase_							     =							LEDTokenizer
							lowercase_							     =							LEDTokenizerFast
							lowercase_							     =							True







							def   __lowerCAmelCase     (    self			:    int   )     ->				List[Any]:


														"""simple docstring"""


														super().setUp()
														_a      	=							[
														    '''l''',
														    '''o''',
														    '''w''',
														    '''e''',
														    '''r''',
														    '''s''',
														    '''t''',
														    '''i''',
														    '''d''',
														    '''n''',
														    '''\u0120''',
														    '''\u0120l''',
														    '''\u0120n''',
														    '''\u0120lo''',
														    '''\u0120low''',
														    '''er''',
														    '''\u0120lowest''',
														    '''\u0120newer''',
														    '''\u0120wider''',
														    '''<unk>''',
														]
														_a      	=							dict(zip(lowerCAmelCase_				,     range(len(lowerCAmelCase_   )   )   )   )
														_a      	=							['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
														_a      	=							{'''unk_token''': '''<unk>'''}

														_a      	=							os.path.join(self.tmpdirname				,     VOCAB_FILES_NAMES['''vocab_file''']   )
														_a      	=							os.path.join(self.tmpdirname				,     VOCAB_FILES_NAMES['''merges_file''']   )
														with open(self.vocab_file				,     '''w'''				,     encoding='''utf-8'''   ) as fp:
																					fp.write(json.dumps(lowerCAmelCase_   ) + '''\n'''   )
														with open(self.merges_file				,     '''w'''				,     encoding='''utf-8'''   ) as fp:
																					fp.write('''\n'''.join(lowerCAmelCase_   )   )







							def   __lowerCAmelCase     (    self			:    Union[str, Any]				,     **lowerCAmelCase_			:    int   )     ->				Optional[int]:


														"""simple docstring"""


														kwargs.update(self.special_tokens_map   )
														return self.tokenizer_class.from_pretrained(self.tmpdirname				,     **lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Optional[Any]				,     **lowerCAmelCase_			:    Any   )     ->				int:


														"""simple docstring"""


														kwargs.update(self.special_tokens_map   )
														return self.rust_tokenizer_class.from_pretrained(self.tmpdirname				,     **lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Optional[Any]				,     lowerCAmelCase_			:    Dict   )     ->				List[str]:


														"""simple docstring"""


														return "lower newer", "lower newer"







							@cached_property
							def   __lowerCAmelCase     (    self			:    Dict   )     ->				int:


														"""simple docstring"""


														return LEDTokenizer.from_pretrained('''allenai/led-base-16384'''   )







							@cached_property
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				Union[str, Any]:


														"""simple docstring"""


														return LEDTokenizerFast.from_pretrained('''allenai/led-base-16384'''   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    int   )     ->				Tuple:


														"""simple docstring"""


														_a      	=							['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
														_a      	=							[0, 2_50, 2_51, 1_78_18, 13, 3_91_86, 19_38, 4, 2]

														for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																					_a      	=							tokenizer(lowerCAmelCase_				,     max_length=len(lowerCAmelCase_   )				,     padding=lowerCAmelCase_				,     return_tensors='''pt'''   )
																					self.assertIsInstance(lowerCAmelCase_				,     lowerCAmelCase_   )

																					self.assertEqual((2, 9)				,     batch.input_ids.shape   )
																					self.assertEqual((2, 9)				,     batch.attention_mask.shape   )
																					_a      	=							batch.input_ids.tolist()[0]
																					self.assertListEqual(lowerCAmelCase_				,     lowerCAmelCase_   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
														for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																					_a      	=							tokenizer(lowerCAmelCase_				,     padding=lowerCAmelCase_				,     return_tensors='''pt'''   )
																					self.assertIn('''input_ids'''				,     lowerCAmelCase_   )
																					self.assertIn('''attention_mask'''				,     lowerCAmelCase_   )
																					self.assertNotIn('''labels'''				,     lowerCAmelCase_   )
																					self.assertNotIn('''decoder_attention_mask'''				,     lowerCAmelCase_   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				str:


														"""simple docstring"""


														_a      	=							[
														    '''Summary of the text.''',
														    '''Another summary.''',
														]
														for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																					_a      	=							tokenizer(text_target=lowerCAmelCase_				,     max_length=32				,     padding='''max_length'''				,     return_tensors='''pt'''   )
																					self.assertEqual(32				,     targets['''input_ids'''].shape[1]   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    Any   )     ->				Union[str, Any]:


														"""simple docstring"""


														for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																					_a      	=							tokenizer(
																					    ['''I am a small frog''' * 10_24, '''I am a small frog''']				,     padding=lowerCAmelCase_				,     truncation=lowerCAmelCase_				,     return_tensors='''pt'''   )
																					self.assertIsInstance(lowerCAmelCase_				,     lowerCAmelCase_   )
																					self.assertEqual(batch.input_ids.shape				,     (2, 51_22)   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    Optional[Any]   )     ->				Union[str, Any]:


														"""simple docstring"""


														_a      	=							['''A long paragraph for summarization.''']
														_a      	=							[
														    '''Summary of the text.''',
														]
														for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																					_a      	=							tokenizer(lowerCAmelCase_				,     return_tensors='''pt'''   )
																					_a      	=							tokenizer(text_target=lowerCAmelCase_				,     return_tensors='''pt'''   )
																					_a      	=							inputs['''input_ids''']
																					_a      	=							targets['''input_ids''']
																					self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()   )
																					self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()   )
																					self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()   )
																					self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()   )







							@require_torch
							def   __lowerCAmelCase     (    self			:    Any   )     ->				Union[str, Any]:


														"""simple docstring"""


														for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																					_a      	=							['''Summary of the text.''', '''Another summary.''']
																					_a      	=							[[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, -1]]

																					_a      	=							tokenizer(lowerCAmelCase_				,     padding=lowerCAmelCase_   )
																					_a      	=							[[0] * len(lowerCAmelCase_   ) for x in encoded_output['''input_ids''']]
																					_a      	=							tokenizer.pad(lowerCAmelCase_   )
																					self.assertSequenceEqual(outputs['''global_attention_mask''']				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Any   )     ->				Dict:


														"""simple docstring"""


														pass







							def   __lowerCAmelCase     (    self			:    Any   )     ->				Optional[Any]:


														"""simple docstring"""


														for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																					with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'   ):
																												_a      	=							self.rust_tokenizer_class.from_pretrained(lowerCAmelCase_				,     **lowerCAmelCase_   )
																												_a      	=							self.tokenizer_class.from_pretrained(lowerCAmelCase_				,     **lowerCAmelCase_   )
																												_a      	=							'''A, <mask> AllenNLP sentence.'''
																												_a      	=							tokenizer_r.encode_plus(lowerCAmelCase_				,     add_special_tokens=lowerCAmelCase_				,     return_token_type_ids=lowerCAmelCase_   )
																												_a      	=							tokenizer_p.encode_plus(lowerCAmelCase_				,     add_special_tokens=lowerCAmelCase_				,     return_token_type_ids=lowerCAmelCase_   )
																												self.assertEqual(sum(tokens_r['''token_type_ids''']   )				,     sum(tokens_p['''token_type_ids''']   )   )
																												self.assertEqual(
																												    sum(tokens_r['''attention_mask''']   ) / len(tokens_r['''attention_mask''']   )				,     sum(tokens_p['''attention_mask''']   ) / len(tokens_p['''attention_mask''']   )				,     )

																												_a      	=							tokenizer_r.convert_ids_to_tokens(tokens_r['''input_ids''']   )
																												_a      	=							tokenizer_p.convert_ids_to_tokens(tokens_p['''input_ids''']   )
																												self.assertSequenceEqual(tokens_p['''input_ids''']				,     [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]   )
																												self.assertSequenceEqual(tokens_r['''input_ids''']				,     [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]   )

																												self.assertSequenceEqual(
																												    lowerCAmelCase_				,     ['''<s>''', '''A''', ''',''', '''<mask>''', '''ĠAllen''', '''N''', '''LP''', '''Ġsentence''', '''.''', '''</s>''']   )
																												self.assertSequenceEqual(
																												    lowerCAmelCase_				,     ['''<s>''', '''A''', ''',''', '''<mask>''', '''ĠAllen''', '''N''', '''LP''', '''Ġsentence''', '''.''', '''</s>''']   )

