

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




def 						UpperCamelCase	(			a		,						a=False		,						a=False		,						a=False			)				->     Union[str, Any]:






     '''simple docstring'''
     __magic_name__						       =    []
     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	(			a		,						a			)				->     List[str]:






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




def 						UpperCamelCase	(			a			)				->     Tuple:






     '''simple docstring'''
     __magic_name__						       =    ['''head.weight''', '''head.bias''']
     for k in ignore_keys:
          state_dict.pop(a		,						a			)




def 						UpperCamelCase	(			a		,						a		,						a			)				->     Optional[Any]:






     '''simple docstring'''
     __magic_name__						       =    dct.pop(a			)
     __magic_name__						       =    val




@torch.no_grad()
def 						UpperCamelCase	(			a		,						a			)				->     Union[str, Any]:






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

     # load state_dict of original model, remove and rename some keys
     __magic_name__						       =    torch.hub.load_state_dict_from_url(a		,						map_location='''cpu'''			)['''state_dict''']
     __magic_name__						       =    create_rename_keys(a		,						a		,						a		,						a			)
     for src, dest in rename_keys:
          rename_key(a		,						a		,						a			)
     read_in_q_k_v(a		,						a			)
     if mlm_model or irtr_model:
          __magic_name__						       =    ['''itm_score.fc.weight''', '''itm_score.fc.bias''']
          for k in ignore_keys:
               state_dict.pop(a		,						a			)

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

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

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

     # Verify outputs
     if mlm_model:
          __magic_name__						       =    torch.Size([1, 11, 3_0522]			)
          __magic_name__						       =    torch.tensor([-12.50_61, -12.51_23, -12.51_74]			)
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3]		,						a		,						atol=1e-4			)

          # verify masked token prediction equals "cats"
          __magic_name__						       =    outputs.logits[0, 4, :].argmax(-1			).item()
          assert tokenizer.decode([predicted_id]			) == "cats"
     elif vqa_model:
          __magic_name__						       =    torch.Size([1, 3129]			)
          __magic_name__						       =    torch.tensor([-15.94_95, -18.14_72, -10.30_41]			)
          assert torch.allclose(outputs.logits[0, :3]		,						a		,						atol=1e-4			)
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3]		,						a		,						atol=1e-4			)

          # verify vqa prediction equals "2"
          __magic_name__						       =    outputs.logits.argmax(-1			).item()
          assert model.config.idalabel[predicted_idx] == "2"
     elif nlvr_model:
          __magic_name__						       =    torch.Size([1, 2]			)
          __magic_name__						       =    torch.tensor([-2.87_21, 2.12_91]			)
          assert torch.allclose(outputs.logits[0, :3]		,						a		,						atol=1e-4			)
          assert outputs.logits.shape == expected_shape

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


if __name__ == "__main__":
      _lowerCAmelCase         =						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."
      )

      _lowerCAmelCase         =						parser.parse_args()
      convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)









'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCAmelCase         =						{
    "configuration_clap": [
        "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
        "ClapAudioConfig",
        "ClapConfig",
        "ClapTextConfig",
    ],
    "processing_clap": ["ClapProcessor"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCAmelCase         =						[
          "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
          "ClapModel",
          "ClapPreTrainedModel",
          "ClapTextModel",
          "ClapTextModelWithProjection",
          "ClapAudioModel",
          "ClapAudioModelWithProjection",
      ]
      _lowerCAmelCase         =						["ClapFeatureExtractor"]

if TYPE_CHECKING:
      from .configuration_clap import (
          CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
          ClapAudioConfig,
          ClapConfig,
          ClapTextConfig,
      )
      from .processing_clap import ClapProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_clap import ClapFeatureExtractor
            from .modeling_clap import (
                CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
                ClapAudioModel,
                ClapAudioModelWithProjection,
                ClapModel,
                ClapPreTrainedModel,
                ClapTextModel,
                ClapTextModelWithProjection,
            )


else:
      import sys

      _lowerCAmelCase         =						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






