






'''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()
UpperCAmelCase__						:Optional[Any]          =			logging.get_logger(__name__)
def     __lowercase  (_lowercase,						_lowercase=False,						_lowercase=False,						_lowercase=False     )   ->     Dict:


     """simple docstring"""
     __lowerCamelCase						:       List[Any]				   =				[]
     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     __lowercase  (_lowercase,						_lowercase     )   ->     Optional[Any]:


     """simple docstring"""
     for i in range(config.num_hidden_layers     ):
          __lowerCamelCase						:       Optional[int]				   =				"""vilt."""
          # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
          __lowerCamelCase						:       Dict				   =				state_dict.pop(f"transformer.blocks.{i}.attn.qkv.weight"     )
          __lowerCamelCase						:       str				   =				state_dict.pop(f"transformer.blocks.{i}.attn.qkv.bias"     )
          # next, add query, keys and values (in that order) to the state dict
          __lowerCamelCase						:       List[str]				   =				in_proj_weight[
              : config.hidden_size, :
          ]
          __lowerCamelCase						:       List[str]				   =				in_proj_bias[: config.hidden_size]
          __lowerCamelCase						:       Tuple				   =				in_proj_weight[
              config.hidden_size : config.hidden_size * 2, :
          ]
          __lowerCamelCase						:       int				   =				in_proj_bias[
              config.hidden_size : config.hidden_size * 2
          ]
          __lowerCamelCase						:       List[str]				   =				in_proj_weight[
              -config.hidden_size :, :
          ]
          __lowerCamelCase						:       List[str]				   =				in_proj_bias[-config.hidden_size :]
def     __lowercase  (_lowercase     )   ->     List[Any]:


     """simple docstring"""
     __lowerCamelCase						:       Any				   =				["""head.weight""", """head.bias"""]
     for k in ignore_keys:
          state_dict.pop(_lowercase,						_lowercase     )
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     Optional[int]:


     """simple docstring"""
     __lowerCamelCase						:       Dict				   =				dct.pop(_lowercase     )
     __lowerCamelCase						:       Dict				   =				val
@torch.no_grad()
def     __lowercase  (_lowercase,						_lowercase     )   ->     List[Any]:


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

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

    # load state dict into HuggingFace model
     model.eval()
     if mlm_model:
          __lowerCamelCase   ,      __lowerCamelCase						:       Union[str, Any]				   =				model.load_state_dict(_lowercase,						strict=_lowercase     )
          assert missing_keys == ["mlm_score.decoder.bias"]
     else:
          model.load_state_dict(_lowercase     )

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

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

     # Verify outputs
     if mlm_model:
          __lowerCamelCase						:       Dict				   =				torch.Size([1, 11, 30_522]     )
          __lowerCamelCase						:       Any				   =				torch.tensor([-12.5061, -12.5123, -12.5174]     )
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3],						_lowercase,						atol=1e-4     )

          # verify masked token prediction equals "cats"
          __lowerCamelCase						:       int				   =				outputs.logits[0, 4, :].argmax(-1     ).item()
          assert tokenizer.decode([predicted_id]     ) == "cats"
     elif vqa_model:
          __lowerCamelCase						:       Tuple				   =				torch.Size([1, 3_129]     )
          __lowerCamelCase						:       Optional[Any]				   =				torch.tensor([-15.9495, -18.1472, -10.3041]     )
          assert torch.allclose(outputs.logits[0, :3],						_lowercase,						atol=1e-4     )
          assert outputs.logits.shape == expected_shape
          assert torch.allclose(outputs.logits[0, 0, :3],						_lowercase,						atol=1e-4     )

          # verify vqa prediction equals "2"
          __lowerCamelCase						:       Dict				   =				outputs.logits.argmax(-1     ).item()
          assert model.config.idalabel[predicted_idx] == "2"
     elif nlvr_model:
          __lowerCamelCase						:       Optional[Any]				   =				torch.Size([1, 2]     )
          __lowerCamelCase						:       Optional[int]				   =				torch.tensor([-2.8721, 2.1291]     )
          assert torch.allclose(outputs.logits[0, :3],						_lowercase,						atol=1e-4     )
          assert outputs.logits.shape == expected_shape

     Path(_lowercase     ).mkdir(exist_ok=_lowercase     )
     print(f"Saving model and processor to {pytorch_dump_folder_path}"     )
     model.save_pretrained(_lowercase     )
     processor.save_pretrained(_lowercase     )


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

   UpperCAmelCase__						:str          =			parser.parse_args()
   convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)











'''simple docstring'''

from statistics import mean

import numpy as np
def     __lowercase  (_lowercase,						_lowercase,						_lowercase,						_lowercase     )   ->     list:


     """simple docstring"""
     __lowerCamelCase						:       str				   =				0
     # Number of processes finished
     __lowerCamelCase						:       List[Any]				   =				0
     # Displays the finished process.
     # If it is 0, the performance is completed if it is 1, before the performance.
     __lowerCamelCase						:       int				   =				[0] * no_of_process
     # List to include calculation results
     __lowerCamelCase						:       Optional[int]				   =				[0] * no_of_process

     # Sort by arrival time.
     __lowerCamelCase						:       int				   =				[burst_time[i] for i in np.argsort(_lowercase     )]
     __lowerCamelCase						:       Union[str, Any]				   =				[process_name[i] for i in np.argsort(_lowercase     )]
     arrival_time.sort()

     while no_of_process > finished_process_count:
          __lowerCamelCase						:       Tuple				   =				0
          while finished_process[i] == 1:
               i += 1
          if current_time < arrival_time[i]:
               __lowerCamelCase						:       List[str]				   =				arrival_time[i]

          __lowerCamelCase						:       Dict				   =				0
          # Index showing the location of the process being performed
          __lowerCamelCase						:       Optional[Any]				   =				0
          # Saves the current response ratio.
          __lowerCamelCase						:       List[str]				   =				0
          for i in range(0,						_lowercase     ):
               if finished_process[i] == 0 and arrival_time[i] <= current_time:
                    __lowerCamelCase						:       Optional[int]				   =				(burst_time[i] + (current_time - arrival_time[i])) / burst_time[
                        i
                    ]
               if response_ratio < temp:
                    __lowerCamelCase						:       List[Any]				   =				temp
                    __lowerCamelCase						:       str				   =				i

        # Calculate the turn around time
          __lowerCamelCase						:       Optional[Any]				   =				current_time + burst_time[loc] - arrival_time[loc]
          current_time += burst_time[loc]
          # Indicates that the process has been performed.
          __lowerCamelCase						:       Optional[Any]				   =				1
          # Increase finished_process_count by 1
          finished_process_count += 1

     return turn_around_time
def     __lowercase  (_lowercase,						_lowercase,						_lowercase,						_lowercase     )   ->     list:


     """simple docstring"""
     __lowerCamelCase						:       List[Any]				   =				[0] * no_of_process
     for i in range(0,						_lowercase     ):
          __lowerCamelCase						:       Tuple				   =				turn_around_time[i] - burst_time[i]
     return waiting_time


if __name__ == "__main__":
   UpperCAmelCase__						:List[Any]          =			5
   UpperCAmelCase__						:Tuple          =			["""A""", """B""", """C""", """D""", """E"""]
   UpperCAmelCase__						:Tuple          =			[1, 2, 3, 4, 5]
   UpperCAmelCase__						:List[Any]          =			[1, 2, 3, 4, 5]

   UpperCAmelCase__						:Union[str, Any]          =			calculate_turn_around_time(
       process_name, arrival_time, burst_time, no_of_process
   )
   UpperCAmelCase__						:Optional[int]          =			calculate_waiting_time(
       process_name, turn_around_time, burst_time, no_of_process
   )

   print("""Process name \tArrival time \tBurst time \tTurn around time \tWaiting time""")
   for i in range(0, no_of_process):
      print(
          f'''{process_name[i]}\t\t{arrival_time[i]}\t\t{burst_time[i]}\t\t'''
          f'''{turn_around_time[i]}\t\t\t{waiting_time[i]}'''
      )

   print(f'''average waiting time : {mean(waiting_time):.5f}''')
   print(f'''average turn around time : {mean(turn_around_time):.5f}''')



