import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class       snake_case					(      lowercase_   ,						unittest.TestCase						):
		lowercase_			=     CLIPTokenizer
		lowercase_			=     CLIPTokenizerFast
		lowercase_			=     True
		lowercase_			=     {}
		lowercase_			=     False




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




							"""simple docstring"""
							super().setUp()

							# fmt: off
							SCREAMING_SNAKE_CASE__				:				Any			=		["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
							# fmt: on
							SCREAMING_SNAKE_CASE__				:				Tuple			=		dict(zip(lowerCamelCase_     , range(len(lowerCamelCase_				)				)				)				)
							SCREAMING_SNAKE_CASE__				:				int			=		["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>"""]
							SCREAMING_SNAKE_CASE__				:				str			=		{"""unk_token""": """<unk>"""}

							SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		os.path.join(self.tmpdirname     , VOCAB_FILES_NAMES['vocab_file']				)
							SCREAMING_SNAKE_CASE__				:				Any			=		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 	__lowercase(      self     :	Union[str, Any]     , **a_     :	Any				)->       Union[str, Any]:




							"""simple docstring"""
							kwargs.update(self.special_tokens_map				)
							return CLIPTokenizer.from_pretrained(self.tmpdirname     , **lowerCamelCase_				)




		def 	__lowercase(      self     :	Dict     , **a_     :	Any				)->       List[Any]:




							"""simple docstring"""
							kwargs.update(self.special_tokens_map				)
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname     , **lowerCamelCase_				)




		def 	__lowercase(      self     :	Dict     , a_     :	Optional[int]				)->       Union[str, Any]:




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		"""lower newer"""
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		"""lower newer"""
							return input_text, output_text




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




							"""simple docstring"""
							SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		CLIPTokenizer(self.vocab_file     , self.merges_file     , **self.special_tokens_map				)
							SCREAMING_SNAKE_CASE__				:				List[Any]			=		"""lower newer"""
							SCREAMING_SNAKE_CASE__				:				Dict			=		["""lo""", """w""", """er</w>""", """n""", """e""", """w""", """er</w>"""]
							SCREAMING_SNAKE_CASE__				:				Tuple			=		tokenizer.tokenize(lowerCamelCase_				)
							self.assertListEqual(lowerCamelCase_     , lowerCamelCase_				)

							SCREAMING_SNAKE_CASE__				:				str			=		tokens + [tokenizer.unk_token]
							SCREAMING_SNAKE_CASE__				:				Optional[int]			=		[10, 2, 16, 9, 3, 2, 16, 20]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_				)     , lowerCamelCase_				)




		@require_ftfy
		def 	__lowercase(      self     :	Optional[Any]				)->       List[str]:




							"""simple docstring"""



							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
												with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
																	SCREAMING_SNAKE_CASE__				:				Dict			=		self.tokenizer_class.from_pretrained(lowerCamelCase_     , **lowerCamelCase_				)
																	SCREAMING_SNAKE_CASE__				:				List[str]			=		self.rust_tokenizer_class.from_pretrained(lowerCamelCase_     , **lowerCamelCase_				)

																	SCREAMING_SNAKE_CASE__				:				Optional[int]			=		"""A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."""
																	SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		tokenizer_s.tokenize(lowerCamelCase_				)
																	SCREAMING_SNAKE_CASE__				:				Tuple			=		tokenizer_r.tokenize(lowerCamelCase_				)

																	self.assertListEqual(lowerCamelCase_     , lowerCamelCase_				)

																	# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
																	# with Tilde) encoded in 2 different ways
																	SCREAMING_SNAKE_CASE__				:				int			=		"""xa\u0303y""" + """ """ + """x\xe3y"""
																	SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		tokenizer_s.tokenize(lowerCamelCase_				)
																	SCREAMING_SNAKE_CASE__				:				Optional[int]			=		tokenizer_r.tokenize(lowerCamelCase_				)

																	self.assertListEqual(lowerCamelCase_     , lowerCamelCase_				)

																	# Test that the tokenization is identical on unicode of space type
																	SCREAMING_SNAKE_CASE__				:				str			=		[
																	    """\u0009""",  # (horizontal tab, '\t')
																	    """\u000B""",  # (vertical tab)
																	    """\u000C""",  # (form feed)
																	    """\u0020""",  # (space, ' ')
																	    """\u200E""",  # (left-to-right mark):w
																	    """\u200F""",  # (right-to-left mark)
																	]
																	for unicode_seq in spaces_unicodes:
																						SCREAMING_SNAKE_CASE__				:				int			=		tokenizer_s.tokenize(lowerCamelCase_				)
																						SCREAMING_SNAKE_CASE__				:				Tuple			=		tokenizer_r.tokenize(lowerCamelCase_				)

																						self.assertListEqual(lowerCamelCase_     , lowerCamelCase_				)

																	# Test that the tokenization is identical on unicode of line break type
																	SCREAMING_SNAKE_CASE__				:				Dict			=		[
																	    """\u000A""",  # (line feed, '\n')
																	    """\r\n""",  # (carriage return and line feed, '\r\n')
																	    """\u000D""",  # (carriage return, '\r')
																	    """\r""",  # (carriage return, '\r')
																	    """\u000D""",  # (carriage return, '\r')
																	    """\u2028""",  # (line separator)
																	    """\u2029""",  # (paragraph separator)
																	    # "\u0085", # (next line)
																	]

																	# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
																	# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
																	# space (and thus into an empty list).

																	for unicode_seq in line_break_unicodes:
																						SCREAMING_SNAKE_CASE__				:				str			=		tokenizer_s.tokenize(lowerCamelCase_				)
																						SCREAMING_SNAKE_CASE__				:				str			=		tokenizer_r.tokenize(lowerCamelCase_				)

																						self.assertListEqual(lowerCamelCase_     , lowerCamelCase_				)




		def 	__lowercase(      self     :	str				)->       Optional[Any]:




							"""simple docstring"""



							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
												with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
																	SCREAMING_SNAKE_CASE__				:				List[Any]			=		"""hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
																	SCREAMING_SNAKE_CASE__				:				Dict			=		F'''{text_of_1_token} {text_of_1_token}'''

																	SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		self.rust_tokenizer_class.from_pretrained(
																	    lowerCamelCase_     , use_fast=lowerCamelCase_     , )
																	SCREAMING_SNAKE_CASE__				:				Any			=		tokenizer_r(lowerCamelCase_     , return_offsets_mapping=lowerCamelCase_     , add_special_tokens=lowerCamelCase_				)
																	self.assertEqual(encoding.offset_mapping[0]     , (0, len(lowerCamelCase_				))				)
																	self.assertEqual(
																	    encoding.offset_mapping[1]     , (len(lowerCamelCase_				) + 1, len(lowerCamelCase_				) + 1 + len(lowerCamelCase_				))     , )

																	SCREAMING_SNAKE_CASE__				:				Optional[int]			=		F''' {text}'''

																	SCREAMING_SNAKE_CASE__				:				Tuple			=		self.rust_tokenizer_class.from_pretrained(
																	    lowerCamelCase_     , use_fast=lowerCamelCase_     , )
																	SCREAMING_SNAKE_CASE__				:				Tuple			=		tokenizer_r(lowerCamelCase_     , return_offsets_mapping=lowerCamelCase_     , add_special_tokens=lowerCamelCase_				)
																	self.assertEqual(encoding.offset_mapping[0]     , (1, 1 + len(lowerCamelCase_				))				)
																	self.assertEqual(
																	    encoding.offset_mapping[1]     , (1 + len(lowerCamelCase_				) + 1, 1 + len(lowerCamelCase_				) + 1 + len(lowerCamelCase_				))     , )




		def 	__lowercase(      self     :	int				)->       Dict:




							"""simple docstring"""



							with self.assertRaises(lowerCamelCase_				) as context:
												self.rust_tokenizer_class.from_pretrained('robot-test/old-clip-tokenizer'				)

							self.assertTrue(
							    context.exception.args[0].startswith(
							        'The `backend_tokenizer` provided does not match the expected format.'				)				)




		@require_ftfy
		def 	__lowercase(      self     :	int				)->       Any:




							"""simple docstring"""
							super().test_tokenization_python_rust_equals()




		def 	__lowercase(      self     :	List[Any]				)->       Union[str, Any]:




							"""simple docstring"""
							pass




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







def     _a				(      lowercase__  :			Union[str, Any]     ,  lowercase__  :			Union[str, Any]=False     ,  lowercase__  :			str=False     ,  lowercase__  :			Dict=False ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		[]
     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     _a				(      lowercase__  :			List[str]     ,  lowercase__  :			Dict ):







     '''simple docstring'''


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







def     _a				(      lowercase__  :			Optional[int] ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				int			=		['head.weight', 'head.bias']
     for k in ignore_keys:
          state_dict.pop(lowercase__     ,  lowercase__ )







def     _a				(      lowercase__  :			int     ,  lowercase__  :			int     ,  lowercase__  :			Dict ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Tuple			=		dct.pop(lowercase__ )
     SCREAMING_SNAKE_CASE__				:				Any			=		val







@torch.no_grad()
def     _a				(      lowercase__  :			Dict     ,  lowercase__  :			Optional[Any] ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				List[Any]			=		ViltConfig(image_size=3_84     ,  patch_size=32     ,  tie_word_embeddings=lowercase__ )
     SCREAMING_SNAKE_CASE__				:				List[str]			=		False
     SCREAMING_SNAKE_CASE__				:				Tuple			=		False
     SCREAMING_SNAKE_CASE__				:				List[str]			=		False
     SCREAMING_SNAKE_CASE__				:				str			=		False
     if "vqa" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				Any			=		True
          SCREAMING_SNAKE_CASE__				:				str			=		31_29
          SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		'huggingface/label-files'
          SCREAMING_SNAKE_CASE__				:				int			=		'vqa2-id2label.json'
          SCREAMING_SNAKE_CASE__				:				str			=		json.load(open(hf_hub_download(lowercase__     ,  lowercase__     ,  repo_type='dataset' )     ,  'r' ) )
          SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		{int(lowercase__ ): v for k, v in idalabel.items()}
          SCREAMING_SNAKE_CASE__				:				Dict			=		idalabel
          SCREAMING_SNAKE_CASE__				:				str			=		{v: k for k, v in idalabel.items()}
          SCREAMING_SNAKE_CASE__				:				List[str]			=		ViltForQuestionAnswering(lowercase__ )
     elif "nlvr" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		True
          SCREAMING_SNAKE_CASE__				:				List[str]			=		2
          SCREAMING_SNAKE_CASE__				:				Dict			=		{0: 'False', 1: 'True'}
          SCREAMING_SNAKE_CASE__				:				Dict			=		{v: k for k, v in config.idalabel.items()}
          SCREAMING_SNAKE_CASE__				:				Tuple			=		3
          SCREAMING_SNAKE_CASE__				:				int			=		ViltForImagesAndTextClassification(lowercase__ )
     elif "irtr" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				Dict			=		True
          SCREAMING_SNAKE_CASE__				:				str			=		ViltForImageAndTextRetrieval(lowercase__ )
     elif "mlm_itm" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				int			=		True
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		ViltForMaskedLM(lowercase__ )
     else:
          raise ValueError('Unknown model type' )

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

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

     # Define processor
     SCREAMING_SNAKE_CASE__				:				str			=		ViltImageProcessor(size=3_84 )
     SCREAMING_SNAKE_CASE__				:				List[Any]			=		BertTokenizer.from_pretrained('bert-base-uncased' )
     SCREAMING_SNAKE_CASE__				:				List[Any]			=		ViltProcessor(lowercase__     ,  lowercase__ )

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

     # Verify outputs
     if mlm_model:
          SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		torch.Size([1, 11, 3_05_22] )
          SCREAMING_SNAKE_CASE__				:				List[str]			=		torch.tensor([-12.5061, -12.5123, -12.5174] )
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3]     ,  lowercase__     ,  atol=1E-4 )

          # verify masked token prediction equals "cats"
          SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		outputs.logits[0, 4, :].argmax(-1 ).item()
          assert tokenizer.decode([predicted_id] ) == "cats"
     elif vqa_model:
          SCREAMING_SNAKE_CASE__				:				str			=		torch.Size([1, 31_29] )
          SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		torch.tensor([-15.9495, -18.1472, -10.3041] )
          assert torch.allclose(outputs.logits[0, :3]     ,  lowercase__     ,  atol=1E-4 )
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3]     ,  lowercase__     ,  atol=1E-4 )

          # verify vqa prediction equals "2"
          SCREAMING_SNAKE_CASE__				:				List[Any]			=		outputs.logits.argmax(-1 ).item()
          assert model.config.idalabel[predicted_idx] == "2"
     elif nlvr_model:
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		torch.Size([1, 2] )
          SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		torch.tensor([-2.8721, 2.1291] )
          assert torch.allclose(outputs.logits[0, :3]     ,  lowercase__     ,  atol=1E-4 )
          assert outputs.logits.shape == expected_shape

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


if __name__ == "__main__":
      SCREAMING_SNAKE_CASE__		:					str						=					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."
      )

      SCREAMING_SNAKE_CASE__		:					List[Any]						=					parser.parse_args()
      convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)



