





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






def 					A__				(			UpperCamelCase					,  UpperCamelCase=False					,  UpperCamelCase=False					,  UpperCamelCase=False       ):
							A		=  []
							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__				(			UpperCamelCase					,  UpperCamelCase       ):

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






def 					A__				(			UpperCamelCase       ):
							A		=  ["head.weight", "head.bias"]
							for k in ignore_keys:
														state_dict.pop(UpperCamelCase					,  UpperCamelCase       )






def 					A__				(			UpperCamelCase					,  UpperCamelCase					,  UpperCamelCase       ):
							A		=  dct.pop(UpperCamelCase       )
							A		=  val






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

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

							# Define processor
							A		=  ViltImageProcessor(size=384       )
							A		=  BertTokenizer.from_pretrained("bert-base-uncased"       )
							A		=  ViltProcessor(UpperCamelCase					,  UpperCamelCase       )

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

							# Verify outputs
							if mlm_model:
														A		=  torch.Size([1, 11, 30_522]       )
														A		=  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"
														A		=  outputs.logits[0, 4, :].argmax(-1       ).item()
														assert tokenizer.decode([predicted_id]       ) == "cats"
							elif vqa_model:
														A		=  torch.Size([1, 3_129]       )
														A		=  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"
														A		=  outputs.logits.argmax(-1       ).item()
														assert model.config.idalabel[predicted_idx] == "2"
							elif nlvr_model:
														A		=  torch.Size([1, 2]       )
														A		=  torch.tensor([-2.87_21, 2.12_91]       )
														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__":
		_snake_case     :		List[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.'
		)

		_snake_case     :		Tuple       						= parser.parse_args()
		convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)




from decimal import Decimal, getcontext
from math import ceil, factorial


def       A       (					lowercase )   ->  str:
		'''simple docstring'''

		if not isinstance(lowercase    ,       lowercase ):
				raise TypeError('Undefined for non-integers' )
		elif precision < 1:
				raise ValueError('Undefined for non-natural numbers' )

		UpperCamelCase		=     precision
		UpperCamelCase		=     ceil(precision / 14 )
		UpperCamelCase		=     426_880 * Decimal(10_005 ).sqrt()
		UpperCamelCase		=     1
		UpperCamelCase		=     13_591_409
		UpperCamelCase		=     Decimal(lowercase )
		for k in range(1    ,       lowercase ):
				UpperCamelCase		=     factorial(6 * k ) // (factorial(3 * k ) * factorial(lowercase ) ** 3)
				linear_term += 545_140_134
				exponential_term *= -262_537_412_640_768_000
				partial_sum += Decimal(multinomial_term * linear_term ) / exponential_term
		return str(constant_term / partial_sum )[:-1]


if __name__ == "__main__":
					_UpperCAmelCase					: Dict      =       50
					print(F'''The first {n} digits of pi is: {pi(n)}''')
