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


def       lowercase_      (      _lowerCamelCase:		Optional[int]  ,      _lowerCamelCase:		Tuple=False  ,      _lowerCamelCase:		str=False  ,      _lowerCamelCase:		int=False					)       ->					Optional[Any]:



							'''simple docstring'''

							__lowerCamelCase    :						int						      =   []
							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       lowercase_      (      _lowerCamelCase:		Optional[int]  ,      _lowerCamelCase:		Union[str, Any]					)       ->					Tuple:



							'''simple docstring'''

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


def       lowercase_      (      _lowerCamelCase:		Optional[int]					)       ->					List[str]:



							'''simple docstring'''

							__lowerCamelCase    :						Tuple						      =   ["head.weight", "head.bias"]
							for k in ignore_keys:
														state_dict.pop(_lowerCamelCase  ,      _lowerCamelCase					)


def       lowercase_      (      _lowerCamelCase:		int  ,      _lowerCamelCase:		Union[str, Any]  ,      _lowerCamelCase:		Optional[Any]					)       ->					Optional[Any]:



							'''simple docstring'''

							__lowerCamelCase    :						Tuple						      =   dct.pop(_lowerCamelCase					)
							__lowerCamelCase    :						Any						      =   val


@torch.no_grad()
def       lowercase_      (      _lowerCamelCase:		Dict  ,      _lowerCamelCase:		Optional[int]					)       ->					Optional[Any]:



							'''simple docstring'''

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

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

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

							# Define processor
							__lowerCamelCase    :						List[str]						      =   ViltImageProcessor(size=384					)
							__lowerCamelCase    :						Optional[Any]						      =   BertTokenizer.from_pretrained("bert-base-uncased"					)
							__lowerCamelCase    :						List[str]						      =   ViltProcessor(_lowerCamelCase  ,      _lowerCamelCase					)

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

							# Verify outputs
							if mlm_model:
														__lowerCamelCase    :						int						      =   torch.Size([1, 11, 30522]					)
														__lowerCamelCase    :						int						      =   torch.tensor([-12.5061, -12.5123, -12.5174]					)
														assert outputs.logits.shape == expected_shape
														assert torch.allclose(outputs.logits[0, 0, :3]  ,      _lowerCamelCase  ,      atol=1E-4					)

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

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

							Path(_lowerCamelCase					).mkdir(exist_ok=_lowerCamelCase					)
							print(F"""Saving model and processor to {pytorch_dump_folder_path}"""					)
							model.save_pretrained(_lowerCamelCase					)
							processor.save_pretrained(_lowerCamelCase					)


if __name__ == "__main__":
				__A     = 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     = parser.parse_args()
				convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)



"""simple docstring"""



from typing import Dict

from .base import GenericTensor, Pipeline







class _lowerCAmelCase				(      snake_case_	):







   def  lowerCamelCase		(	self						,	UpperCamelCase__=None						,	UpperCamelCase__=None						,	UpperCamelCase__=None						,	**UpperCamelCase__						)	->		Union[str, Any]:

       '''simple docstring'''




       if tokenize_kwargs is None:
           snake_case    :      Optional[Any]      					=    {}

       if truncation is not None:
           if "truncation" in tokenize_kwargs:
               raise ValueError(
                   "truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)"						)
           snake_case    :      List[str]      					=    truncation

       snake_case    :      Union[str, Any]      					=    tokenize_kwargs

       snake_case    :      List[Any]      					=    {}
       if return_tensors is not None:
           snake_case    :      Tuple      					=    return_tensors

       return preprocess_params, {}, postprocess_params







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	**UpperCamelCase__						)	->		Dict[str, GenericTensor]:

       '''simple docstring'''




       snake_case    :      List[Any]      					=    self.framework
       snake_case    :      str      					=    self.tokenizer(UpperCamelCase__						,	return_tensors=UpperCamelCase__						,	**UpperCamelCase__						)
       return model_inputs







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Tuple:

       '''simple docstring'''




       snake_case    :      int      					=    self.model(**UpperCamelCase__						)
       return model_outputs







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__=False						)	->		Union[str, Any]:

       '''simple docstring'''




       if return_tensors:
           return model_outputs[0]
       if self.framework == "pt":
           return model_outputs[0].tolist()
       elif self.framework == "tf":
           return model_outputs[0].numpy().tolist()







   def __call__(	self						,	*UpperCamelCase__						,	**UpperCamelCase__						)	->		Union[str, Any]:

       '''simple docstring'''




       return super().__call__(*UpperCamelCase__						,	**UpperCamelCase__						)





