


'''simple docstring'''



import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__A						=logging.get_logger(__name__)

__A						={
    'BAAI/AltCLIP': 'https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}


class 		_snake_case       (  SCREAMING_SNAKE_CASE__						):
					lowerCAmelCase   :List[Any]				=       '''altclip_text_model'''




					def __init__(   self				,				_lowerCamelCase=25_0002				,				_lowerCamelCase=1024				,				_lowerCamelCase=24				,				_lowerCamelCase=16				,				_lowerCamelCase=4096				,				_lowerCamelCase="gelu"				,				_lowerCamelCase=0.1				,				_lowerCamelCase=0.1				,				_lowerCamelCase=514				,				_lowerCamelCase=1				,				_lowerCamelCase=0.02				,				_lowerCamelCase=0.02				,				_lowerCamelCase=1e-0_5				,				_lowerCamelCase=1				,				_lowerCamelCase=0				,				_lowerCamelCase=2				,				_lowerCamelCase="absolute"				,				_lowerCamelCase=True				,				_lowerCamelCase=768				,				**_lowerCamelCase				,				):
								super().__init__(pad_token_id=A_				,				bos_token_id=A_				,				eos_token_id=A_				,				**A_)

								UpperCAmelCase__	:       Any   =  vocab_size
								UpperCAmelCase__	:       Optional[int]   =  hidden_size
								UpperCAmelCase__	:       Any   =  num_hidden_layers
								UpperCAmelCase__	:       List[Any]   =  num_attention_heads
								UpperCAmelCase__	:       Any   =  hidden_act
								UpperCAmelCase__	:       Tuple   =  intermediate_size
								UpperCAmelCase__	:       Optional[int]   =  hidden_dropout_prob
								UpperCAmelCase__	:       str   =  attention_probs_dropout_prob
								UpperCAmelCase__	:       str   =  max_position_embeddings
								UpperCAmelCase__	:       Any   =  type_vocab_size
								UpperCAmelCase__	:       int   =  initializer_range
								UpperCAmelCase__	:       Optional[int]   =  initializer_factor
								UpperCAmelCase__	:       Union[str, Any]   =  layer_norm_eps
								UpperCAmelCase__	:       str   =  position_embedding_type
								UpperCAmelCase__	:       Any   =  use_cache
								UpperCAmelCase__	:       Any   =  project_dim


class 		_snake_case       (  SCREAMING_SNAKE_CASE__						):
					lowerCAmelCase   :Optional[Any]				=       '''altclip_vision_model'''




					def __init__(   self				,				_lowerCamelCase=768				,				_lowerCamelCase=3072				,				_lowerCamelCase=512				,				_lowerCamelCase=12				,				_lowerCamelCase=12				,				_lowerCamelCase=3				,				_lowerCamelCase=224				,				_lowerCamelCase=32				,				_lowerCamelCase="quick_gelu"				,				_lowerCamelCase=1e-5				,				_lowerCamelCase=0.0				,				_lowerCamelCase=0.02				,				_lowerCamelCase=1.0				,				**_lowerCamelCase				,				):
								super().__init__(**A_)

								UpperCAmelCase__	:       Optional[Any]   =  hidden_size
								UpperCAmelCase__	:       Optional[Any]   =  intermediate_size
								UpperCAmelCase__	:       Any   =  projection_dim
								UpperCAmelCase__	:       Union[str, Any]   =  num_hidden_layers
								UpperCAmelCase__	:       Any   =  num_attention_heads
								UpperCAmelCase__	:       int   =  num_channels
								UpperCAmelCase__	:       Dict   =  patch_size
								UpperCAmelCase__	:       Tuple   =  image_size
								UpperCAmelCase__	:       Tuple   =  initializer_range
								UpperCAmelCase__	:       Dict   =  initializer_factor
								UpperCAmelCase__	:       List[str]   =  attention_dropout
								UpperCAmelCase__	:       Optional[int]   =  layer_norm_eps
								UpperCAmelCase__	:       Any   =  hidden_act




					@classmethod
					def 					snake_case__    (   cls				,				_lowerCamelCase				,				**_lowerCamelCase):
								cls._set_token_in_kwargs(A_)

								UpperCAmelCase__	:       Any   =  cls.get_config_dict(A_				,				**A_)

								# get the vision config dict if we are loading from AltCLIPConfig
								if config_dict.get("""model_type""") == "altclip":
											UpperCAmelCase__	:       int   =  config_dict['''vision_config''']

								if "model_type" in config_dict and hasattr(cls				,				"""model_type""") and config_dict["model_type"] != cls.model_type:
											logger.warning(
											    f'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
											    f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''')

								return cls.from_dict(A_				,				**A_)


class 		_snake_case       (  SCREAMING_SNAKE_CASE__						):
					lowerCAmelCase   :int				=       '''altclip'''
					lowerCAmelCase   :str				=       True




					def __init__(   self				,				_lowerCamelCase=None				,				_lowerCamelCase=None				,				_lowerCamelCase=768				,				_lowerCamelCase=2.6592				,				**_lowerCamelCase):
								UpperCAmelCase__	:       Union[str, Any]   =  kwargs.pop("""text_config_dict"""				,				A_)
								UpperCAmelCase__	:       Tuple   =  kwargs.pop("""vision_config_dict"""				,				A_)

								super().__init__(**A_)

								# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
								# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
								# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
								if text_config_dict is not None:
											if text_config is None:
														UpperCAmelCase__	:       str   =  {}

											# This is the complete result when using `text_config_dict`.
											UpperCAmelCase__	:       Dict   =  AltCLIPTextConfig(**A_).to_dict()

											# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
											for key, value in _text_config_dict.items():
														if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
																	# If specified in `text_config_dict`
																	if key in text_config_dict:
																				UpperCAmelCase__	:       List[Any]   =  (
																				    f'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. '''
																				    f'''The value `text_config_dict["{key}"]` will be used instead.'''
																				)
																	# If inferred from default argument values (just to be super careful)
																	else:
																				UpperCAmelCase__	:       Tuple   =  (
																				    f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
																				    f'''value `text_config["{key}"]` will be overriden.'''
																				)
																	logger.warning(A_)

            # Update all values in `text_config` with the ones in `_text_config_dict`.
											text_config.update(_text_config_dict)

								if vision_config_dict is not None:
											if vision_config is None:
														UpperCAmelCase__	:       Union[str, Any]   =  {}

											# This is the complete result when using `vision_config_dict`.
											UpperCAmelCase__	:       List[Any]   =  AltCLIPVisionConfig(**A_).to_dict()
											# convert keys to string instead of integer
											if "id2label" in _vision_config_dict:
														UpperCAmelCase__	:       Tuple   =  {
														    str(A_): value for key, value in _vision_config_dict['''id2label'''].items()
														}

											# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
											for key, value in _vision_config_dict.items():
														if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
																	# If specified in `vision_config_dict`
																	if key in vision_config_dict:
																				UpperCAmelCase__	:       Tuple   =  (
																				    f'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different '''
																				    f'''values. The value `vision_config_dict["{key}"]` will be used instead.'''
																				)
																	# If inferred from default argument values (just to be super careful)
																	else:
																				UpperCAmelCase__	:       List[Any]   =  (
																				    f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
																				    f'''The value `vision_config["{key}"]` will be overriden.'''
																				)
																	logger.warning(A_)

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
											vision_config.update(_vision_config_dict)

								if text_config is None:
											UpperCAmelCase__	:       List[str]   =  {}
											logger.info("""`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.""")

								if vision_config is None:
											UpperCAmelCase__	:       Optional[Any]   =  {}
											logger.info("""`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.""")

								UpperCAmelCase__	:       str   =  AltCLIPTextConfig(**A_)
								UpperCAmelCase__	:       List[str]   =  AltCLIPVisionConfig(**A_)

								UpperCAmelCase__	:       Any   =  projection_dim
								UpperCAmelCase__	:       Tuple   =  logit_scale_init_value
								UpperCAmelCase__	:       Tuple   =  1.0




					@classmethod
					def 					snake_case__    (   cls				,				_lowerCamelCase				,				_lowerCamelCase				,				**_lowerCamelCase):
								return cls(text_config=text_config.to_dict()				,				vision_config=vision_config.to_dict()				,				**A_)




					def 					snake_case__    (   self):
								UpperCAmelCase__	:       str   =  copy.deepcopy(self.__dict__)
								UpperCAmelCase__	:       str   =  self.text_config.to_dict()
								UpperCAmelCase__	:       List[Any]   =  self.vision_config.to_dict()
								UpperCAmelCase__	:       List[str]   =  self.__class__.model_type
								return output

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




def 			_lowerCAmelCase		(		_UpperCamelCase			,					_UpperCamelCase=False			,					_UpperCamelCase=False			,					_UpperCamelCase=False    ):






  """simple docstring"""



  _lowercase:      Tuple   			=  []
  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 			_lowerCAmelCase		(		_UpperCamelCase			,					_UpperCamelCase    ):






  """simple docstring"""



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




def 			_lowerCAmelCase		(		_UpperCamelCase    ):






  """simple docstring"""



  _lowercase:      Optional[int]   			=  ['''head.weight''', '''head.bias''']
  for k in ignore_keys:
    state_dict.pop(_UpperCamelCase			,					_UpperCamelCase    )




def 			_lowerCAmelCase		(		_UpperCamelCase			,					_UpperCamelCase			,					_UpperCamelCase    ):






  """simple docstring"""



  _lowercase:      List[str]   			=  dct.pop(_UpperCamelCase    )
  _lowercase:      Dict   			=  val




@torch.no_grad()
def 			_lowerCAmelCase		(		_UpperCamelCase			,					_UpperCamelCase    ):






  """simple docstring"""



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

  # load state_dict of original model, remove and rename some keys
  _lowercase:      List[Any]   			=  torch.hub.load_state_dict_from_url(_UpperCamelCase			,					map_location='''cpu'''    )['''state_dict''']
  _lowercase:      Dict   			=  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:
    _lowercase:      int   			=  ['''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:
    _lowercase			,					_lowercase:      Optional[int]   			=  model.load_state_dict(_UpperCamelCase			,					strict=_UpperCamelCase    )
    assert missing_keys == ["mlm_score.decoder.bias"]
  else:
    model.load_state_dict(_UpperCamelCase    )

  # Define processor
  _lowercase:      int   			=  ViltImageProcessor(size=384    )
  _lowercase:      List[str]   			=  BertTokenizer.from_pretrained('''bert-base-uncased'''    )
  _lowercase:      List[Any]   			=  ViltProcessor(_UpperCamelCase			,					_UpperCamelCase    )

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

  # Verify outputs
  if mlm_model:
    _lowercase:      List[str]   			=  torch.Size([1, 11, 30_522]    )
    _lowercase:      Tuple   			=  torch.tensor([-12.5_061, -12.5_123, -12.5_174]    )
    assert outputs.logits.shape == expected_shape
    assert torch.allclose(outputs.logits[0, 0, :3]			,					_UpperCamelCase			,					atol=1e-4    )

    # verify masked token prediction equals "cats"
    _lowercase:      Optional[int]   			=  outputs.logits[0, 4, :].argmax(-1    ).item()
    assert tokenizer.decode([predicted_id]    ) == "cats"
  elif vqa_model:
    _lowercase:      Optional[int]   			=  torch.Size([1, 3_129]    )
    _lowercase:      List[str]   			=  torch.tensor([-15.9_495, -18.1_472, -10.3_041]    )
    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"
    _lowercase:      List[Any]   			=  outputs.logits.argmax(-1    ).item()
    assert model.config.idalabel[predicted_idx] == "2"
  elif nlvr_model:
    _lowercase:      Tuple   			=  torch.Size([1, 2]    )
    _lowercase:      Any   			=  torch.tensor([-2.8_721, 2.1_291]    )
    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__":
  A__ :       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.'
  )

  A__ :       str				= parser.parse_args()
  convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
