





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







def    a__							(							lowercase   :	Optional[int],   lowercase   :	Union[str, Any]=False,   lowercase   :	int=False,   lowercase   :	Optional[int]=False )						->						Dict:





     """simple docstring"""

     _UpperCamelCase							       =			[]
     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   :	List[str] )						->						Any:





     """simple docstring"""

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







def    a__							(							lowercase   :	Dict )						->						str:





     """simple docstring"""

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







def    a__							(							lowercase   :	Any,   lowercase   :	int,   lowercase   :	List[str] )						->						List[Any]:





     """simple docstring"""

     _UpperCamelCase							       =			dct.pop(lowercase )
     _UpperCamelCase							       =			val







@torch.no_grad()
def    a__							(							lowercase   :	int,   lowercase   :	List[str] )						->						List[Any]:





     """simple docstring"""

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

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

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

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

     # Verify outputs
     if mlm_model:
          _UpperCamelCase							       =			torch.Size([1, 11, 30522] )
          _UpperCamelCase							       =			torch.tensor([-1_2.5_0_6_1, -1_2.5_1_2_3, -1_2.5_1_7_4] )
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3],   lowercase,   atol=1e-4 )

          # verify masked token prediction equals "cats"
          _UpperCamelCase							       =			outputs.logits[0, 4, :].argmax(-1 ).item()
          assert tokenizer.decode([predicted_id] ) == "cats"
     elif vqa_model:
          _UpperCamelCase							       =			torch.Size([1, 3129] )
          _UpperCamelCase							       =			torch.tensor([-1_5.9_4_9_5, -1_8.1_4_7_2, -1_0.3_0_4_1] )
          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"
          _UpperCamelCase							       =			outputs.logits.argmax(-1 ).item()
          assert model.config.idalabel[predicted_idx] == "2"
     elif nlvr_model:
          _UpperCamelCase							       =			torch.Size([1, 2] )
          _UpperCamelCase							       =			torch.tensor([-2.8_7_2_1, 2.1_2_9_1] )
          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__":
   lowercase__		:     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.'
   )

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










'''simple docstring'''

def    a__							(							lowercase   :	int,   lowercase   :	int,   lowercase   :	int )						->						float:





     """simple docstring"""

     _UpperCamelCase							       =			(num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff)
     # formula for sum of series
     return total







def    a__							(							)						->						Tuple:





     """simple docstring"""

     print(sum_of_series(1,   1,   10 ) )


if __name__ == "__main__":
   import doctest

   doctest.testmod()



