



'''simple docstring'''







import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling
def 			_lowerCAmelCase(      UpperCAmelCase_      :	Tuple						) ->							Any:
							lowerCAmelCase__  =   "https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"

							with open(snake_case_					, """wb"""						) as f:
														with requests.get(snake_case_					, stream=snake_case_						) as req:
																					for chunk in req.iter_content(chunk_size=2048						):
																												f.write(snake_case_						)
def 			_lowerCAmelCase(      ) ->							List[Any]:
							lowerCAmelCase__  =   VivitConfig()

							lowerCAmelCase__  =   400
							lowerCAmelCase__  =   "huggingface/label-files"
							lowerCAmelCase__  =   "kinetics400-id2label.json"

							lowerCAmelCase__  =   json.load(open(hf_hub_download(snake_case_					, snake_case_					, repo_type="""dataset"""						)					, """r"""						)						)
							lowerCAmelCase__  =   {int(snake_case_						): v for k, v in idalabel.items()}
							lowerCAmelCase__  =   idalabel
							lowerCAmelCase__  =   {v: k for k, v in idalabel.items()}
							return config
def 			_lowerCAmelCase(      ) ->							List[Any]:
							lowerCAmelCase__  =   hf_hub_download(
							    repo_id="""hf-internal-testing/spaghetti-video"""					, filename="""eating_spaghetti_32_frames.npy"""					, repo_type="""dataset"""						)
							lowerCAmelCase__  =   np.load(snake_case_						)
							return list(snake_case_						)
def 			_lowerCAmelCase(      UpperCAmelCase_      :	List[str]						) ->							Tuple:





							if np.ndim(snake_case_						) == 2:
														return transform_attention_bias(snake_case_						)

							elif np.ndim(snake_case_						) == 3:
														return transform_attention_kernel(snake_case_						)

							else:
														raise Exception(F'''Invalid number of dimesions: {np.ndim(snake_case_						)}'''						)
def 			_lowerCAmelCase(      UpperCAmelCase_      :	Union[str, Any]						) ->							Union[str, Any]:
							return current.flatten()
def 			_lowerCAmelCase(      UpperCAmelCase_      :	Dict						) ->							Union[str, Any]:
							return np.reshape(snake_case_					, (current.shape[0], current.shape[1] * current.shape[2])						).T
def 			_lowerCAmelCase(      UpperCAmelCase_      :	List[Any]						) ->							Optional[Any]:
							return np.reshape(snake_case_					, (current.shape[0] * current.shape[1], current.shape[2])						).T
def 			_lowerCAmelCase(      UpperCAmelCase_      :	Optional[int]					, UpperCAmelCase_      :	str						) ->							int:
							lowerCAmelCase__  =   state_dict["optimizer"]["target"]["Transformer"][F'''encoderblock_{i}''']

							lowerCAmelCase__  =   F'''encoder.layer.{i}.'''
							lowerCAmelCase__  =   {
							    prefix + "intermediate.dense.bias": state["MlpBlock_0"]["Dense_0"]["bias"],
							    prefix + "intermediate.dense.weight": np.transpose(state["""MlpBlock_0"""]["""Dense_0"""]["""kernel"""]						),
							    prefix + "output.dense.bias": state["MlpBlock_0"]["Dense_1"]["bias"],
							    prefix + "output.dense.weight": np.transpose(state["""MlpBlock_0"""]["""Dense_1"""]["""kernel"""]						),
							    prefix + "layernorm_before.bias": state["LayerNorm_0"]["bias"],
							    prefix + "layernorm_before.weight": state["LayerNorm_0"]["scale"],
							    prefix + "layernorm_after.bias": state["LayerNorm_1"]["bias"],
							    prefix + "layernorm_after.weight": state["LayerNorm_1"]["scale"],
							    prefix
							    + "attention.attention.query.bias": transform_attention(
							        state["""MultiHeadDotProductAttention_0"""]["""query"""]["""bias"""]						),
							    prefix
							    + "attention.attention.query.weight": transform_attention(
							        state["""MultiHeadDotProductAttention_0"""]["""query"""]["""kernel"""]						),
							    prefix
							    + "attention.attention.key.bias": transform_attention(state["""MultiHeadDotProductAttention_0"""]["""key"""]["""bias"""]						),
							    prefix
							    + "attention.attention.key.weight": transform_attention(
							        state["""MultiHeadDotProductAttention_0"""]["""key"""]["""kernel"""]						),
							    prefix
							    + "attention.attention.value.bias": transform_attention(
							        state["""MultiHeadDotProductAttention_0"""]["""value"""]["""bias"""]						),
							    prefix
							    + "attention.attention.value.weight": transform_attention(
							        state["""MultiHeadDotProductAttention_0"""]["""value"""]["""kernel"""]						),
							    prefix + "attention.output.dense.bias": state["MultiHeadDotProductAttention_0"]["out"]["bias"],
							    prefix
							    + "attention.output.dense.weight": transform_attention_output_weight(
							        state["""MultiHeadDotProductAttention_0"""]["""out"""]["""kernel"""]						),
							}

							return new_state
def 			_lowerCAmelCase(      UpperCAmelCase_      :	Tuple						) ->							str:
							return sum([1 if """encoderblock_""" in k else 0 for k in state_dict["""optimizer"""]["""target"""]["""Transformer"""].keys()]						)
def 			_lowerCAmelCase(      UpperCAmelCase_      :	Tuple					, UpperCAmelCase_      :	List[str]=False						) ->							int:
							lowerCAmelCase__  =   get_n_layers(snake_case_						)

							lowerCAmelCase__  =   OrderedDict()

							lowerCAmelCase__  =   state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
							lowerCAmelCase__  =   state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]

							lowerCAmelCase__  =   np.transpose(
							    state_dict["""optimizer"""]["""target"""]["""embedding"""]["""kernel"""]					, (4, 3, 0, 1, 2)						)
							lowerCAmelCase__  =   state_dict["optimizer"]["target"]["embedding"]["bias"]

							lowerCAmelCase__  =   state_dict["optimizer"]["target"]["cls"]
							lowerCAmelCase__  =   state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
							    "pos_embedding"
							]

							for i in range(snake_case_						):
														new_state.update(transform_state_encoder_block(snake_case_					, snake_case_						)						)

							if classification_head:
														lowerCAmelCase__  =   {"vivit." + k: v for k, v in new_state.items()}
														lowerCAmelCase__  =   np.transpose(state_dict["""optimizer"""]["""target"""]["""output_projection"""]["""kernel"""]						)
														lowerCAmelCase__  =   np.transpose(state_dict["""optimizer"""]["""target"""]["""output_projection"""]["""bias"""]						)

							return {k: torch.tensor(snake_case_						) for k, v in new_state.items()}
def 			_lowerCAmelCase(      ) ->							Dict:
							lowerCAmelCase__  =   VivitImageProcessor()

							assert extractor.do_resize is True
							assert extractor.size == {"shortest_edge": 256}
							assert extractor.do_center_crop is True
							assert extractor.crop_size == {"width": 224, "height": 224}
							assert extractor.resample == PILImageResampling.BILINEAR

							# here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
							# one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
							# which effectively means no normalization (and ViViT does not overwrite those when calling this func)
							assert extractor.do_normalize is False
							assert extractor.do_rescale is True
							assert extractor.rescale_factor == 1 / 255

							# zero-centering = True in original implementation
							assert extractor.do_zero_centering is True

							return extractor
def 			_lowerCAmelCase(      UpperCAmelCase_      :	int						) ->							List[str]:
							lowerCAmelCase__  =   "checkpoint"

							if not os.path.exists(snake_case_						):
														download_checkpoint(snake_case_						)

							lowerCAmelCase__  =   restore_checkpoint(snake_case_					, snake_case_						)
							lowerCAmelCase__  =   transform_state(snake_case_					, classification_head=snake_case_						)

							lowerCAmelCase__  =   get_vivit_config()

							assert config.image_size == 224
							assert config.num_frames == 32

							lowerCAmelCase__  =   VivitForVideoClassification(snake_case_						)
							model.load_state_dict(snake_case_						)
							model.eval()

							lowerCAmelCase__  =   get_processor()

							lowerCAmelCase__  =   prepare_video()
							lowerCAmelCase__  =   extractor(snake_case_					, return_tensors="""pt"""						)

							lowerCAmelCase__  =   model(**snake_case_						)

							lowerCAmelCase__  =   torch.Size([1, 400]						)
							lowerCAmelCase__  =   torch.tensor([-1.05_43, 2.07_64, -0.21_04, 0.44_39, -0.96_58]						)

							assert outputs.logits.shape == expected_shape
							assert torch.allclose(outputs.logits[0, :5]					, snake_case_					, atol=1E-4						), outputs.logits[0, :5]

							model.save_pretrained(snake_case_						)
							extractor.save_pretrained(snake_case_						)


if __name__ == "__main__":
		_UpperCamelCase  						=			argparse.ArgumentParser()

		parser.add_argument("""--output_model_name""", """-o""", type=str, help="""Output path for the converted HuggingFace model""")

		_UpperCamelCase  						=			parser.parse_args()
		convert(args.output_model_name)













"""simple docstring"""





import argparse
import json
import re
import string
import sys
from collections import Counter






def 							A(    snake_case_						):
       """simple docstring"""





       def remove_articles(snake_case_						):
              return re.sub(r"\b(a|an|the)\b"		,  " "		,  snake_case_						)

       def white_space_fix(snake_case_						):
              return " ".join(text.split()						)

       def remove_punc(snake_case_						):
              lowercase__:							str         =     set(string.punctuation						)
              return "".join(ch for ch in text if ch not in exclude						)

       def lower(snake_case_						):
              return text.lower()

       return white_space_fix(remove_articles(remove_punc(lower(snake_case_						)						)						)						)






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       lowercase__:							Dict         =     normalize_answer(snake_case_						).split()
       lowercase__:							List[str]         =     normalize_answer(snake_case_						).split()
       lowercase__:							Optional[int]         =     Counter(snake_case_						) & Counter(snake_case_						)
       lowercase__:							Any         =     sum(common.values()						)
       if num_same == 0:
              return 0
       lowercase__:							Any         =     1.0 * num_same / len(snake_case_						)
       lowercase__:							List[Any]         =     1.0 * num_same / len(snake_case_						)
       lowercase__:							int         =     (2 * precision * recall) / (precision + recall)
       return fa






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       return normalize_answer(snake_case_						) == normalize_answer(snake_case_						)






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       lowercase__:							int         =     []
       for ground_truth in ground_truths:
              lowercase__:							str         =     metric_fn(snake_case_		,  snake_case_						)
              scores_for_ground_truths.append(snake_case_						)
       return max(snake_case_						)






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       lowercase__:							Optional[int]         =     0
       for article in dataset:
              for paragraph in article["paragraphs"]:
                     for qa in paragraph["qas"]:
                            total += 1
                            if qa["id"] not in predictions:
                                   lowercase__:							Union[str, Any]         =     "Unanswered question " + qa["id"] + " will receive score 0."
                                   print(snake_case_		,  file=sys.stderr						)
                                   continue
                            lowercase__:							List[Any]         =     [x["text"] for x in qa["answers"]]
                            lowercase__:							Optional[Any]         =     predictions[qa["id"]]
                            exact_match += metric_max_over_ground_truths(snake_case_		,  snake_case_		,  snake_case_						)
                            fa += metric_max_over_ground_truths(snake_case_		,  snake_case_		,  snake_case_						)

       lowercase__:							Union[str, Any]         =     1_00.0 * exact_match / total
       lowercase__:							str         =     1_00.0 * fa / total

       return {"exact_match": exact_match, "f1": fa}


if __name__ == "__main__":
  UpperCamelCase					=     """1.1"""
  UpperCamelCase					=     argparse.ArgumentParser(description="""Evaluation for SQuAD """ + expected_version)
  parser.add_argument("""dataset_file""", help="""Dataset file""")
  parser.add_argument("""prediction_file""", help="""Prediction File""")
  UpperCamelCase					=     parser.parse_args()
  with open(args.dataset_file) as dataset_file:
    UpperCamelCase					=     json.load(dataset_file)
    if dataset_json["version"] != expected_version:
      print(
          """Evaluation expects v-""" + expected_version + """, but got dataset with v-""" + dataset_json["""version"""],
          file=sys.stderr,
      )
    UpperCamelCase					=     dataset_json["""data"""]
  with open(args.prediction_file) as prediction_file:
    UpperCamelCase					=     json.load(prediction_file)
  print(json.dumps(evaluate(dataset, predictions)))






