
'''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 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE=False,		__SCREAMING_SNAKE_CASE=False,		__SCREAMING_SNAKE_CASE=False       ):
    """simple docstring"""






    snake_case_ :    Union[str, 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 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






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

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    List[str]     			=						["head.weight", "head.bias"]
    for k in ignore_keys:
        state_dict.pop(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       )

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Optional[Any]     			=						dct.pop(__SCREAMING_SNAKE_CASE       )
    snake_case_ :    Optional[int]     			=						val

@torch.no_grad()
def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






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

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

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

    # Define processor
    snake_case_ :    Tuple     			=						ViltImageProcessor(size=3_8_4       )
    snake_case_ :    Tuple     			=						BertTokenizer.from_pretrained("bert-base-uncased"       )
    snake_case_ :    List[Any]     			=						ViltProcessor(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       )

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

    # Verify outputs
    if mlm_model:
        snake_case_ :    str     			=						torch.Size([1, 1_1, 3_0_5_2_2]       )
        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],		__SCREAMING_SNAKE_CASE,		atol=1E-4       )

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

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

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


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 __future__ import annotations

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    List[Any]     			=						0.00
    snake_case_ :    int     			=						0
    for resistor in resistors:
        if resistor <= 0:
            snake_case_ :    Dict     			=						f'Resistor at index {index} has a negative or zero value!'
            raise ValueError(__SCREAMING_SNAKE_CASE       )
        first_sum += 1 / float(__SCREAMING_SNAKE_CASE       )
        index += 1
    return 1 / first_sum

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Union[str, Any]     			=						0.00
    snake_case_ :    List[Any]     			=						0
    for resistor in resistors:
        sum_r += resistor
        if resistor < 0:
            snake_case_ :    str     			=						f'Resistor at index {index} has a negative value!'
            raise ValueError(__SCREAMING_SNAKE_CASE       )
        index += 1
    return sum_r


if __name__ == "__main__":
  import doctest

  doctest.testmod()




