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




def 	A_ (							snake_case							:   Union[str, Any] ,      snake_case							:   Dict=False ,      snake_case							:   Optional[Any]=False ,      snake_case							:   Tuple=False )      ->    int:



						'''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_ (							snake_case							:   Optional[int] ,      snake_case							:   Dict )      ->    Optional[int]:



						'''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_ (							snake_case							:   Union[str, Any] )      ->    Any:



						'''simple docstring'''

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




def 	A_ (							snake_case							:   str ,      snake_case							:   int ,      snake_case							:   int )      ->    List[Any]:



						'''simple docstring'''

						__UpperCamelCase       =			dct.pop(lowerCamelCase_ )
						__UpperCamelCase       =			val




@torch.no_grad()
def 	A_ (							snake_case							:   Tuple ,      snake_case							:   int )      ->    Any:



						'''simple docstring'''

						__UpperCamelCase       =			ViltConfig(image_size=384 ,      patch_size=32 ,      tie_word_embeddings=lowerCamelCase_ )
						__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(lowerCamelCase_ ,      lowerCamelCase_ ,      repo_type='''dataset''' ) ,      '''r''' ) )
												__UpperCamelCase       =			{int(lowerCamelCase_ ): v for k, v in idalabel.items()}
												__UpperCamelCase       =			idalabel
												__UpperCamelCase       =			{v: k for k, v in idalabel.items()}
												__UpperCamelCase       =			ViltForQuestionAnswering(lowerCamelCase_ )
						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(lowerCamelCase_ )
						elif "irtr" in checkpoint_url:
												__UpperCamelCase       =			True
												__UpperCamelCase       =			ViltForImageAndTextRetrieval(lowerCamelCase_ )
						elif "mlm_itm" in checkpoint_url:
												__UpperCamelCase       =			True
												__UpperCamelCase       =			ViltForMaskedLM(lowerCamelCase_ )
						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(lowerCamelCase_ ,      map_location='''cpu''' )['''state_dict''']
						__UpperCamelCase       =			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:
												__UpperCamelCase       =			['''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:
												__UpperCamelCase       =			model.load_state_dict(lowerCamelCase_ ,      strict=lowerCamelCase_ )
												assert missing_keys == ["mlm_score.decoder.bias"]
						else:
												model.load_state_dict(lowerCamelCase_ )

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

						# 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=lowerCamelCase_ ).raw )
												__UpperCamelCase       =			Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg''' ,      stream=lowerCamelCase_ ).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(lowerCamelCase_ ,      lowerCamelCase_ ,      return_tensors='''pt''' )
												__UpperCamelCase       =			processor(lowerCamelCase_ ,      lowerCamelCase_ ,      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=lowerCamelCase_ ).raw )
												if mlm_model:
																		__UpperCamelCase       =			'''a bunch of [MASK] laying on a [MASK].'''
												else:
																		__UpperCamelCase       =			'''How many cats are there?'''
												__UpperCamelCase       =			processor(lowerCamelCase_ ,      lowerCamelCase_ ,      return_tensors='''pt''' )
												__UpperCamelCase       =			model(**lowerCamelCase_ )

						# Verify outputs
						if mlm_model:
												__UpperCamelCase       =			torch.Size([1, 11, 30522] )
												__UpperCamelCase       =			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"
												__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([-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"
												__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.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__":
					lowercase__							:							Optional[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__							:							Tuple									=			parser.parse_args()
					convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)






from collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean




def 	A_ (							snake_case							:   int )      ->    int:



						'''simple docstring'''

						def is_in_circle(snake_case							:   float ,      snake_case							:   float ) -> bool:
												__UpperCamelCase       =			sqrt((x**2) + (y**2) )
												# Our circle has a radius of 1, so a distance
												# greater than 1 would land outside the circle.
												return distance_from_centre <= 1

						# The proportion of guesses that landed in the circle
						__UpperCamelCase       =			mean(
						    int(is_in_circle(uniform(-1.0 ,      1.0 ) ,      uniform(-1.0 ,      1.0 ) ) )
						    for _ in range(snake_case ) )
						# The ratio of the area for circle to square is pi/4.
						__UpperCamelCase       =			proportion * 4
						print(f"The estimated value of pi is {pi_estimate}" )
						print(f"The numpy value of pi is {pi}" )
						print(f"The total error is {abs(pi - pi_estimate )}" )




def 	A_ (							snake_case							:   int ,      snake_case							:   Callable[[float], float] ,      snake_case							:   float = 0.0 ,      snake_case							:   float = 1.0 ,      )      ->    float:



						'''simple docstring'''

						return mean(
						    function_to_integrate(uniform(snake_case ,      snake_case ) ) for _ in range(snake_case ) ) * (max_value - min_value)




def 	A_ (							snake_case							:   int ,      snake_case							:   float = 0.0 ,      snake_case							:   float = 1.0 )      ->    None:



						'''simple docstring'''

						def identity_function(snake_case							:   float ) -> float:
												return x

						__UpperCamelCase       =			area_under_curve_estimator(
						    snake_case ,      snake_case ,      snake_case ,      snake_case )
						__UpperCamelCase       =			(max_value * max_value - min_value * min_value) / 2

						print('''******************''' )
						print(f"Estimating area under y=x where x varies from {min_value} to {max_value}" )
						print(f"Estimated value is {estimated_value}" )
						print(f"Expected value is {expected_value}" )
						print(f"Total error is {abs(estimated_value - expected_value )}" )
						print('''******************''' )




def 	A_ (							snake_case							:   int )      ->    None:



						'''simple docstring'''

						def function_to_integrate(snake_case							:   float ) -> float:
												return sqrt(4.0 - x * x )

						__UpperCamelCase       =			area_under_curve_estimator(
						    snake_case ,      snake_case ,      0.0 ,      2.0 )

						print('''******************''' )
						print('''Estimating pi using area_under_curve_estimator''' )
						print(f"Estimated value is {estimated_value}" )
						print(f"Expected value is {pi}" )
						print(f"Total error is {abs(estimated_value - pi )}" )
						print('''******************''' )


if __name__ == "__main__":
				import doctest

				doctest.testmod()




