



"""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:     Union[str, Any]										=	logging.get_logger(__name__)

def    _snake_case		(		UpperCamelCase		:	int    ,	UpperCamelCase		:	Optional[Any]=False    ,	UpperCamelCase		:	Optional[Any]=False    ,	UpperCamelCase		:	str=False		):
 UpperCAmelCase			:      List[str]			=			[]
 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    _snake_case		(		UpperCamelCase		:	Optional[int]    ,	UpperCamelCase		:	Tuple		):
 for i in range(config.num_hidden_layers		):
  UpperCAmelCase			:      List[Any]			=			"""vilt."""
  # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
  UpperCAmelCase			:      List[str]			=			state_dict.pop(F"transformer.blocks.{i}.attn.qkv.weight"		)
  UpperCAmelCase			:      Any			=			state_dict.pop(F"transformer.blocks.{i}.attn.qkv.bias"		)
  # next, add query, keys and values (in that order) to the state dict
  UpperCAmelCase			:      List[str]			=			in_proj_weight[
      : config.hidden_size, :
  ]
  UpperCAmelCase			:      int			=			in_proj_bias[: config.hidden_size]
  UpperCAmelCase			:      List[Any]			=			in_proj_weight[
      config.hidden_size : config.hidden_size * 2, :
  ]
  UpperCAmelCase			:      Optional[int]			=			in_proj_bias[
      config.hidden_size : config.hidden_size * 2
  ]
  UpperCAmelCase			:      Any			=			in_proj_weight[
      -config.hidden_size :, :
  ]
  UpperCAmelCase			:      Any			=			in_proj_bias[-config.hidden_size :]

def    _snake_case		(		UpperCamelCase		:	List[str]		):
 UpperCAmelCase			:      Dict			=			["""head.weight""", """head.bias"""]
 for k in ignore_keys:
  state_dict.pop(UpperCamelCase    ,	UpperCamelCase		)

def    _snake_case		(		UpperCamelCase		:	Optional[Any]    ,	UpperCamelCase		:	str    ,	UpperCamelCase		:	List[str]		):
 UpperCAmelCase			:      Any			=			dct.pop(UpperCamelCase		)
 UpperCAmelCase			:      Dict			=			val

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

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

 # Define processor
 UpperCAmelCase			:      Optional[int]			=			ViltImageProcessor(size=384		)
 UpperCAmelCase			:      str			=			BertTokenizer.from_pretrained("""bert-base-uncased"""		)
 UpperCAmelCase			:      int			=			ViltProcessor(UpperCamelCase    ,	UpperCamelCase		)

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

 # Verify outputs
 if mlm_model:
  UpperCAmelCase			:      str			=			torch.Size([1, 11, 30522]		)
  UpperCAmelCase			:      Dict			=			torch.tensor([-12.5061, -12.5123, -12.5174]		)
  assert outputs.logits.shape == expected_shape
  assert torch.allclose(outputs.logits[0, 0, :3]    ,	UpperCamelCase    ,	atol=1e-4		)

  # verify masked token prediction equals "cats"
  UpperCAmelCase			:      Optional[int]			=			outputs.logits[0, 4, :].argmax(-1		).item()
  assert tokenizer.decode([predicted_id]		) == "cats"
 elif vqa_model:
  UpperCAmelCase			:      Dict			=			torch.Size([1, 3129]		)
  UpperCAmelCase			:      Union[str, Any]			=			torch.tensor([-15.9495, -18.1472, -10.3041]		)
  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"
  UpperCAmelCase			:      int			=			outputs.logits.argmax(-1		).item()
  assert model.config.idalabel[predicted_idx] == "2"
 elif nlvr_model:
  UpperCAmelCase			:      List[str]			=			torch.Size([1, 2]		)
  UpperCAmelCase			:      str			=			torch.tensor([-2.8721, 2.1291]		)
  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__":
      A:     str										=	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:     List[Any]										=	parser.parse_args()
      convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





"""simple docstring"""
import datetime
import platform
import subprocess
from typing import Optional, Tuple, Union

import numpy as np

def    _snake_case		(		UpperCamelCase		:	bytes    ,	UpperCamelCase		:	int		):
 UpperCAmelCase			:      Tuple			=			F"{sampling_rate}"
 UpperCAmelCase			:      Optional[int]			=			"""1"""
 UpperCAmelCase			:      Dict			=			"""f32le"""
 UpperCAmelCase			:      Optional[int]			=			[
     """ffmpeg""",
     """-i""",
     """pipe:0""",
     """-ac""",
     ac,
     """-ar""",
     ar,
     """-f""",
     format_for_conversion,
     """-hide_banner""",
     """-loglevel""",
     """quiet""",
     """pipe:1""",
 ]

 try:
  with subprocess.Popen(UpperCamelCase    ,	stdin=subprocess.PIPE    ,	stdout=subprocess.PIPE		) as ffmpeg_process:
   UpperCAmelCase			:      str			=			ffmpeg_process.communicate(UpperCamelCase		)
 except FileNotFoundError as error:
  raise ValueError("""ffmpeg was not found but is required to load audio files from filename"""		) from error
 UpperCAmelCase			:      Tuple			=			output_stream[0]
 UpperCAmelCase			:      Union[str, Any]			=			np.frombuffer(UpperCamelCase    ,	np.floataa		)
 if audio.shape[0] == 0:
  raise ValueError("""Malformed soundfile"""		)
 return audio

def    _snake_case		(		UpperCamelCase		:	int    ,	UpperCamelCase		:	float    ,	UpperCamelCase		:	str = "f32le"    ,	):
 UpperCAmelCase			:      Tuple			=			F"{sampling_rate}"
 UpperCAmelCase			:      List[str]			=			"""1"""
 if format_for_conversion == "s16le":
  UpperCAmelCase			:      int			=			2
 elif format_for_conversion == "f32le":
  UpperCAmelCase			:      int			=			4
 else:
  raise ValueError(F"Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`"		)

 UpperCAmelCase			:      Optional[Any]			=			platform.system()
 if system == "Linux":
  UpperCAmelCase			:      Tuple			=			"""alsa"""
  UpperCAmelCase			:      Any			=			"""default"""
 elif system == "Darwin":
  UpperCAmelCase			:      Any			=			"""avfoundation"""
  UpperCAmelCase			:      int			=			""":0"""
 elif system == "Windows":
  UpperCAmelCase			:      Optional[int]			=			"""dshow"""
  UpperCAmelCase			:      str			=			"""default"""

 UpperCAmelCase			:      Dict			=			[
     """ffmpeg""",
     """-f""",
     format_,
     """-i""",
     input_,
     """-ac""",
     ac,
     """-ar""",
     ar,
     """-f""",
     format_for_conversion,
     """-fflags""",
     """nobuffer""",
     """-hide_banner""",
     """-loglevel""",
     """quiet""",
     """pipe:1""",
 ]
 UpperCAmelCase			:      str			=			int(round(sampling_rate * chunk_length_s		)		) * size_of_sample
 UpperCAmelCase			:      Union[str, Any]			=			_ffmpeg_stream(UpperCamelCase    ,	UpperCamelCase		)
 for item in iterator:
  yield item

def    _snake_case		(		UpperCamelCase		:	int    ,	UpperCamelCase		:	float    ,	UpperCamelCase		:	Optional[int] = None    ,	UpperCamelCase		:	Optional[Union[Tuple[float, float], float]] = None    ,	UpperCamelCase		:	str = "f32le"    ,	):
 if stream_chunk_s is not None:
  UpperCAmelCase			:      List[Any]			=			stream_chunk_s
 else:
  UpperCAmelCase			:      List[Any]			=			chunk_length_s

 UpperCAmelCase			:      Union[str, Any]			=			ffmpeg_microphone(UpperCamelCase    ,	UpperCamelCase    ,	format_for_conversion=UpperCamelCase		)
 if format_for_conversion == "s16le":
  UpperCAmelCase			:      Dict			=			np.intaa
  UpperCAmelCase			:      Optional[Any]			=			2
 elif format_for_conversion == "f32le":
  UpperCAmelCase			:      Any			=			np.floataa
  UpperCAmelCase			:      Dict			=			4
 else:
  raise ValueError(F"Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`"		)

 if stride_length_s is None:
  UpperCAmelCase			:      Tuple			=			chunk_length_s / 6
 UpperCAmelCase			:      Optional[Any]			=			int(round(sampling_rate * chunk_length_s		)		) * size_of_sample
 if isinstance(UpperCamelCase    ,	(int, float)		):
  UpperCAmelCase			:      str			=			[stride_length_s, stride_length_s]

 UpperCAmelCase			:      List[Any]			=			int(round(sampling_rate * stride_length_s[0]		)		) * size_of_sample
 UpperCAmelCase			:      Optional[int]			=			int(round(sampling_rate * stride_length_s[1]		)		) * size_of_sample
 UpperCAmelCase			:      List[Any]			=			datetime.datetime.now()
 UpperCAmelCase			:      Tuple			=			datetime.timedelta(seconds=UpperCamelCase		)
 for item in chunk_bytes_iter(UpperCamelCase    ,	UpperCamelCase    ,	stride=(stride_left, stride_right)    ,	stream=UpperCamelCase		):
  # Put everything back in numpy scale
  UpperCAmelCase			:      Dict			=			np.frombuffer(item["""raw"""]    ,	dtype=UpperCamelCase		)
  UpperCAmelCase			:      List[str]			=			(
      item["""stride"""][0] // size_of_sample,
      item["""stride"""][1] // size_of_sample,
  )
  UpperCAmelCase			:      Optional[Any]			=			sampling_rate
  audio_time += delta
  if datetime.datetime.now() > audio_time + 10 * delta:
   # We're late !! SKIP
   continue
  yield item

def    _snake_case		(		UpperCamelCase		:	Dict    ,	UpperCamelCase		:	int    ,	UpperCamelCase		:	Tuple[int, int]    ,	UpperCamelCase		:	bool = False		):
 UpperCAmelCase			:      Any			=			B""""""
 UpperCAmelCase			,	UpperCAmelCase			:      List[Any]			=			stride
 if stride_left + stride_right >= chunk_len:
  raise ValueError(
      F"Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}"		)
 UpperCAmelCase			:      int			=			0
 for raw in iterator:
  acc += raw
  if stream and len(UpperCamelCase		) < chunk_len:
   UpperCAmelCase			:      Optional[Any]			=			(_stride_left, 0)
   yield {"raw": acc[:chunk_len], "stride": stride, "partial": True}
  else:
   while len(UpperCamelCase		) >= chunk_len:
    # We are flushing the accumulator
    UpperCAmelCase			:      List[str]			=			(_stride_left, stride_right)
    UpperCAmelCase			:      List[str]			=			{"""raw""": acc[:chunk_len], """stride""": stride}
    if stream:
     UpperCAmelCase			:      List[str]			=			False
    yield item
    UpperCAmelCase			:      Optional[Any]			=			stride_left
    UpperCAmelCase			:      Union[str, Any]			=			acc[chunk_len - stride_left - stride_right :]
    # Last chunk
 if len(UpperCamelCase		) > stride_left:
  UpperCAmelCase			:      Union[str, Any]			=			{"""raw""": acc, """stride""": (_stride_left, 0)}
  if stream:
   UpperCAmelCase			:      str			=			False
  yield item

def    _snake_case		(		UpperCamelCase		:	int    ,	UpperCamelCase		:	int		):
 UpperCAmelCase			:      List[Any]			=			2**24  # 16Mo
 try:
  with subprocess.Popen(UpperCamelCase    ,	stdout=subprocess.PIPE    ,	bufsize=UpperCamelCase		) as ffmpeg_process:
   while True:
    UpperCAmelCase			:      Optional[Any]			=			ffmpeg_process.stdout.read(UpperCamelCase		)
    if raw == b"":
     break
    yield raw
 except FileNotFoundError as error:
  raise ValueError("""ffmpeg was not found but is required to stream audio files from filename"""		) from error
