



'''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__    :   Optional[int]           =					logging.get_logger(__name__)





def   a_   (		_UpperCAmelCase    :      List[str] ,_UpperCAmelCase    :      Union[str, Any]=False ,_UpperCAmelCase    :      Optional[int]=False ,_UpperCAmelCase    :      int=False				)    ->  Dict:
      __snake_case :   int													=    []
      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    :      Optional[int] ,_UpperCAmelCase    :      Any				)    ->  Any:
      for i in range(config.num_hidden_layers				):
            __snake_case :   int													=    'vilt.'
            # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
            __snake_case :   Optional[Any]													=    state_dict.pop(f'''transformer.blocks.{i}.attn.qkv.weight'''				)
            __snake_case :   Any													=    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 :   Any													=    in_proj_weight[
                : config.hidden_size, :
            ]
            __snake_case :   int													=    in_proj_bias[: config.hidden_size]
            __snake_case :   Tuple													=    in_proj_weight[
                config.hidden_size : config.hidden_size * 2, :
            ]
            __snake_case :   List[Any]													=    in_proj_bias[
                config.hidden_size : config.hidden_size * 2
            ]
            __snake_case :   Any													=    in_proj_weight[
                -config.hidden_size :, :
            ]
            __snake_case :   Any													=    in_proj_bias[-config.hidden_size :]





def   a_   (		_UpperCAmelCase    :      Tuple				)    ->  Tuple:
      __snake_case :   Union[str, Any]													=    ['head.weight', 'head.bias']
      for k in ignore_keys:
            state_dict.pop(_UpperCAmelCase ,_UpperCAmelCase				)





def   a_   (		_UpperCAmelCase    :      int ,_UpperCAmelCase    :      List[str] ,_UpperCAmelCase    :      int				)    ->  Any:
      __snake_case :   Union[str, Any]													=    dct.pop(_UpperCAmelCase				)
      __snake_case :   Tuple													=    val





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

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

      # Define processor
      __snake_case :   Optional[int]													=    ViltImageProcessor(size=3_84				)
      __snake_case :   Dict													=    BertTokenizer.from_pretrained('bert-base-uncased'				)
      __snake_case :   List[str]													=    ViltProcessor(_UpperCAmelCase ,_UpperCAmelCase				)

      # Forward pass on example inputs (image + text)
      if nlvr_model:
            __snake_case :   Any													=    Image.open(requests.get('https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg' ,stream=_UpperCAmelCase				).raw				)
            __snake_case :   Union[str, Any]													=    Image.open(requests.get('https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg' ,stream=_UpperCAmelCase				).raw				)
            __snake_case :   List[str]													=    (
                '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(_UpperCAmelCase ,_UpperCAmelCase ,return_tensors='pt'				)
            __snake_case :   Dict													=    processor(_UpperCAmelCase ,_UpperCAmelCase ,return_tensors='pt'				)
            __snake_case :   Tuple													=    model(
                input_ids=encoding_a.input_ids ,pixel_values=encoding_a.pixel_values ,pixel_values_a=encoding_a.pixel_values ,)
      else:
            __snake_case :   Tuple													=    Image.open(requests.get('http://images.cocodataset.org/val2017/000000039769.jpg' ,stream=_UpperCAmelCase				).raw				)
            if mlm_model:
                  __snake_case :   str													=    'a bunch of [MASK] laying on a [MASK].'
            else:
                  __snake_case :   str													=    'How many cats are there?'
            __snake_case :   int													=    processor(_UpperCAmelCase ,_UpperCAmelCase ,return_tensors='pt'				)
            __snake_case :   Tuple													=    model(**_UpperCAmelCase				)

      # Verify outputs
      if mlm_model:
            __snake_case :   Any													=    torch.Size([1, 11, 3_05_22]				)
            __snake_case :   Optional[Any]													=    torch.tensor([-1_2.5_0_6_1, -1_2.5_1_2_3, -1_2.5_1_7_4]				)
            assert outputs.logits.shape == expected_shape
            assert torch.allclose(outputs.logits[0, 0, :3] ,_UpperCAmelCase ,atol=1E-4				)

            # verify masked token prediction equals "cats"
            __snake_case :   str													=    outputs.logits[0, 4, :].argmax(-1				).item()
            assert tokenizer.decode([predicted_id]				) == "cats"
      elif vqa_model:
            __snake_case :   Any													=    torch.Size([1, 31_29]				)
            __snake_case :   Any													=    torch.tensor([-1_5.9_4_9_5, -1_8.1_4_7_2, -1_0.3_0_4_1]				)
            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"
            __snake_case :   Optional[Any]													=    outputs.logits.argmax(-1				).item()
            assert model.config.idalabel[predicted_idx] == "2"
      elif nlvr_model:
            __snake_case :   Dict													=    torch.Size([1, 2]				)
            __snake_case :   List[str]													=    torch.tensor([-2.8_7_2_1, 2.1_2_9_1]				)
            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__    :   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.'''
    )

    A__    :   List[str]           =					parser.parse_args()
    convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








'''simple docstring'''





import functools





def   a_   (		_UpperCAmelCase    :      list[int] ,_UpperCAmelCase    :      list[int]				)    ->  int:

      # Validation
      if not isinstance(_UpperCAmelCase ,_UpperCAmelCase				) or not all(isinstance(_UpperCAmelCase ,_UpperCAmelCase				) for day in days				):
            raise ValueError('The parameter days should be a list of integers'				)

      if len(_UpperCAmelCase				) != 3 or not all(isinstance(_UpperCAmelCase ,_UpperCAmelCase				) for cost in costs				):
            raise ValueError('The parameter costs should be a list of three integers'				)

      if len(_UpperCAmelCase				) == 0:
            return 0

      if min(_UpperCAmelCase				) <= 0:
            raise ValueError('All days elements should be greater than 0'				)

      if max(_UpperCAmelCase				) >= 3_66:
            raise ValueError('All days elements should be less than 366'				)

      __snake_case :   str													=    set(_UpperCAmelCase				)

      @functools.cache
      def dynamic_programming(_UpperCAmelCase    :      int				) -> int:
            if index > 3_65:
                  return 0

            if index not in days_set:
                  return dynamic_programming(index + 1				)

            return min(
                costs[0] + dynamic_programming(index + 1				) ,costs[1] + dynamic_programming(index + 7				) ,costs[2] + dynamic_programming(index + 30				) ,)

      return dynamic_programming(1				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()



