"""simple docstring"""
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowercase__ 	=     logging.get_logger(__name__)

lowercase__ 	=     {
    'hustvl/yolos-small': 'https://huggingface.co/hustvl/yolos-small/resolve/main/config.json',
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}




class        __snake_case	(					__lowerCAmelCase    ):
						a__				=		"""yolos"""



						def __init__(						self   ,      lowercase=7_68   ,      lowercase=12   ,      lowercase=12   ,      lowercase=30_72   ,      lowercase="gelu"   ,      lowercase=0.0   ,      lowercase=0.0   ,      lowercase=0.02   ,      lowercase=1e-12   ,      lowercase=[5_12, 8_64]   ,      lowercase=16   ,      lowercase=3   ,      lowercase=True   ,      lowercase=1_00   ,      lowercase=True   ,      lowercase=False   ,      lowercase=1   ,      lowercase=5   ,      lowercase=2   ,      lowercase=5   ,      lowercase=2   ,      lowercase=0.1   ,      **lowercase   ,      )     ->      Dict:





								'''simple docstring'''





								super().__init__(**lowercase)

								a__:					int      							=     hidden_size
								a__:					Optional[Any]      							=     num_hidden_layers
								a__:					str      							=     num_attention_heads
								a__:					List[str]      							=     intermediate_size
								a__:					Optional[Any]      							=     hidden_act
								a__:					str      							=     hidden_dropout_prob
								a__:					Union[str, Any]      							=     attention_probs_dropout_prob
								a__:					Optional[int]      							=     initializer_range
								a__:					int      							=     layer_norm_eps
								a__:					List[str]      							=     image_size
								a__:					Optional[int]      							=     patch_size
								a__:					Optional[int]      							=     num_channels
								a__:					List[str]      							=     qkv_bias
								a__:					List[Any]      							=     num_detection_tokens
								a__:					Dict      							=     use_mid_position_embeddings
								a__:					Optional[Any]      							=     auxiliary_loss
								# Hungarian matcher
								a__:					Dict      							=     class_cost
								a__:					str      							=     bbox_cost
								a__:					List[Any]      							=     giou_cost
								# Loss coefficients
								a__:					Union[str, Any]      							=     bbox_loss_coefficient
								a__:					Tuple      							=     giou_loss_coefficient
								a__:					Any      							=     eos_coefficient







class        __snake_case	(					__lowerCAmelCase    ):
						a__				=		version.parse("""1.11"""    )



						@property
						def   lowerCamelCase_       (						self)     ->      Mapping[str, Mapping[int, str]]:





								'''simple docstring'''





								return OrderedDict(
								    [
								        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
								    ])



						@property
						def   lowerCamelCase_       (						self)     ->      float:





								'''simple docstring'''





								return 1e-4



						@property
						def   lowerCamelCase_       (						self)     ->      int:





								'''simple docstring'''





								return 12



"""simple docstring"""
import argparse
import collections
import json
import os
import re
import string
import sys

import numpy as np


lowercase__ 	=     re.compile(r'\b(a|an|the)\b', re.UNICODE)

lowercase__ 	=     None







def 						__a       (     )     ->List[Any]:
  a__:					Dict      							=     argparse.ArgumentParser('Official evaluation script for SQuAD version 2.0.'       )
  parser.add_argument('data_file'		,					metavar='data.json'		,					help='Input data JSON file.'       )
  parser.add_argument('pred_file'		,					metavar='pred.json'		,					help='Model predictions.'       )
  parser.add_argument(
      '--out-file'		,					'-o'		,					metavar='eval.json'		,					help='Write accuracy metrics to file (default is stdout).'       )
  parser.add_argument(
      '--na-prob-file'		,					'-n'		,					metavar='na_prob.json'		,					help='Model estimates of probability of no answer.'       )
  parser.add_argument(
      '--na-prob-thresh'		,					'-t'		,					type=_SCREAMING_SNAKE_CASE		,					default=1.0		,					help='Predict "" if no-answer probability exceeds this (default = 1.0).'		,					)
  parser.add_argument(
      '--out-image-dir'		,					'-p'		,					metavar='out_images'		,					default=_SCREAMING_SNAKE_CASE		,					help='Save precision-recall curves to directory.'       )
  parser.add_argument('--verbose'		,					'-v'		,					action='store_true'       )
  if len(sys.argv       ) == 1:
    parser.print_help()
    sys.exit(1       )
  return parser.parse_args()







def 						__a       (     _SCREAMING_SNAKE_CASE       )     ->Union[str, Any]:
  a__:					Optional[int]      							=     {}
  for article in dataset:
    for p in article["paragraphs"]:
      for qa in p["qas"]:
        a__:					Optional[Any]      							=     bool(qa['answers']['text']       )
  return qid_to_has_ans







def 						__a       (     _SCREAMING_SNAKE_CASE       )     ->Optional[Any]:

  def remove_articles(_SCREAMING_SNAKE_CASE       ):
    return ARTICLES_REGEX.sub(' '		,					_SCREAMING_SNAKE_CASE       )

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

  def remove_punc(_SCREAMING_SNAKE_CASE       ):
    a__:					Dict      							=     set(string.punctuation       )
    return "".join(ch for ch in text if ch not in exclude       )

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

  return white_space_fix(remove_articles(remove_punc(lower(_SCREAMING_SNAKE_CASE       )       )       )       )







def 						__a       (     _SCREAMING_SNAKE_CASE       )     ->Optional[int]:
  if not s:
    return []
  return normalize_answer(_SCREAMING_SNAKE_CASE       ).split()







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->List[Any]:
  return int(normalize_answer(_SCREAMING_SNAKE_CASE       ) == normalize_answer(_SCREAMING_SNAKE_CASE       )       )







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->str:
  a__:					Any      							=     get_tokens(_SCREAMING_SNAKE_CASE       )
  a__:					Optional[int]      							=     get_tokens(_SCREAMING_SNAKE_CASE       )
  a__:					Optional[int]      							=     collections.Counter(_SCREAMING_SNAKE_CASE       ) & collections.Counter(_SCREAMING_SNAKE_CASE       )
  a__:					Tuple      							=     sum(common.values()       )
  if len(_SCREAMING_SNAKE_CASE       ) == 0 or len(_SCREAMING_SNAKE_CASE       ) == 0:
    # If either is no-answer, then F1 is 1 if they agree, 0 otherwise
    return int(gold_toks == pred_toks       )
  if num_same == 0:
    return 0
  a__:					Any      							=     1.0 * num_same / len(_SCREAMING_SNAKE_CASE       )
  a__:					Optional[int]      							=     1.0 * num_same / len(_SCREAMING_SNAKE_CASE       )
  a__:					Dict      							=     (2 * precision * recall) / (precision + recall)
  return fa







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->Dict:
  a__:					Union[str, Any]      							=     {}
  a__:					Dict      							=     {}
  for article in dataset:
    for p in article["paragraphs"]:
      for qa in p["qas"]:
        a__:					Optional[int]      							=     qa['id']
        a__:					List[Any]      							=     [t for t in qa['answers']['text'] if normalize_answer(_SCREAMING_SNAKE_CASE       )]
        if not gold_answers:
          # For unanswerable questions, only correct answer is empty string
          a__:					str      							=     ['']
        if qid not in preds:
          print(F'Missing prediction for {qid}'       )
          continue
        a__:					Any      							=     preds[qid]
        # Take max over all gold answers
        a__:					List[str]      							=     max(compute_exact(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       ) for a in gold_answers       )
        a__:					Optional[int]      							=     max(compute_fa(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       ) for a in gold_answers       )
  return exact_scores, fa_scores







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->Optional[Any]:
  a__:					List[str]      							=     {}
  for qid, s in scores.items():
    a__:					List[Any]      							=     na_probs[qid] > na_prob_thresh
    if pred_na:
      a__:					Optional[int]      							=     float(not qid_to_has_ans[qid]       )
    else:
      a__:					Optional[Any]      							=     s
  return new_scores







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE=None       )     ->Tuple:
  if not qid_list:
    a__:					str      							=     len(_SCREAMING_SNAKE_CASE       )
    return collections.OrderedDict(
        [
            ('exact', 100.0 * sum(exact_scores.values()       ) / total),
            ('f1', 100.0 * sum(fa_scores.values()       ) / total),
            ('total', total),
        ]       )
  else:
    a__:					Optional[Any]      							=     len(_SCREAMING_SNAKE_CASE       )
    return collections.OrderedDict(
        [
            ('exact', 100.0 * sum(exact_scores[k] for k in qid_list       ) / total),
            ('f1', 100.0 * sum(fa_scores[k] for k in qid_list       ) / total),
            ('total', total),
        ]       )







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->List[str]:
  for k in new_eval:
    a__:					List[Any]      							=     new_eval[k]







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->str:
  plt.step(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					color='b'		,					alpha=0.2		,					where='post'       )
  plt.fill_between(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					step='post'		,					alpha=0.2		,					color='b'       )
  plt.xlabel('Recall'       )
  plt.ylabel('Precision'       )
  plt.xlim([0.0, 1.05]       )
  plt.ylim([0.0, 1.05]       )
  plt.title(_SCREAMING_SNAKE_CASE       )
  plt.savefig(_SCREAMING_SNAKE_CASE       )
  plt.clf()







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE=None		,					_SCREAMING_SNAKE_CASE=None       )     ->List[str]:
  a__:					Optional[int]      							=     sorted(_SCREAMING_SNAKE_CASE		,					key=lambda _SCREAMING_SNAKE_CASE       : na_probs[k]       )
  a__:					Dict      							=     0.0
  a__:					Optional[int]      							=     1.0
  a__:					Tuple      							=     0.0
  a__:					Tuple      							=     [1.0]
  a__:					Optional[Any]      							=     [0.0]
  a__:					Optional[Any]      							=     0.0
  for i, qid in enumerate(_SCREAMING_SNAKE_CASE       ):
    if qid_to_has_ans[qid]:
      true_pos += scores[qid]
    a__:					Optional[Any]      							=     true_pos / float(i + 1       )
    a__:					int      							=     true_pos / float(_SCREAMING_SNAKE_CASE       )
    if i == len(_SCREAMING_SNAKE_CASE       ) - 1 or na_probs[qid] != na_probs[qid_list[i + 1]]:
      # i.e., if we can put a threshold after this point
      avg_prec += cur_p * (cur_r - recalls[-1])
      precisions.append(_SCREAMING_SNAKE_CASE       )
      recalls.append(_SCREAMING_SNAKE_CASE       )
  if out_image:
    plot_pr_curve(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  return {"ap": 100.0 * avg_prec}







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->int:
  if out_image_dir and not os.path.exists(_SCREAMING_SNAKE_CASE       ):
    os.makedirs(_SCREAMING_SNAKE_CASE       )
  a__:					Any      							=     sum(1 for v in qid_to_has_ans.values() if v       )
  if num_true_pos == 0:
    return
  a__:					Optional[Any]      							=     make_precision_recall_eval(
      _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					out_image=os.path.join(_SCREAMING_SNAKE_CASE		,					'pr_exact.png'       )		,					title='Precision-Recall curve for Exact Match score'		,					)
  a__:					List[str]      							=     make_precision_recall_eval(
      _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					out_image=os.path.join(_SCREAMING_SNAKE_CASE		,					'pr_f1.png'       )		,					title='Precision-Recall curve for F1 score'		,					)
  a__:					Optional[Any]      							=     {k: float(_SCREAMING_SNAKE_CASE       ) for k, v in qid_to_has_ans.items()}
  a__:					List[Any]      							=     make_precision_recall_eval(
      _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					out_image=os.path.join(_SCREAMING_SNAKE_CASE		,					'pr_oracle.png'       )		,					title='Oracle Precision-Recall curve (binary task of HasAns vs. NoAns)'		,					)
  merge_eval(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					'pr_exact'       )
  merge_eval(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					'pr_f1'       )
  merge_eval(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					'pr_oracle'       )







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->List[str]:
  if not qid_list:
    return
  a__:					Any      							=     [na_probs[k] for k in qid_list]
  a__:					List[str]      							=     np.ones_like(_SCREAMING_SNAKE_CASE       ) / float(len(_SCREAMING_SNAKE_CASE       )       )
  plt.hist(_SCREAMING_SNAKE_CASE		,					weights=_SCREAMING_SNAKE_CASE		,					bins=20		,					range=(0.0, 1.0)       )
  plt.xlabel('Model probability of no-answer'       )
  plt.ylabel('Proportion of dataset'       )
  plt.title(F'Histogram of no-answer probability: {name}'       )
  plt.savefig(os.path.join(_SCREAMING_SNAKE_CASE		,					F'na_prob_hist_{name}.png'       )       )
  plt.clf()







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->List[str]:
  a__:					str      							=     sum(1 for k in qid_to_has_ans if not qid_to_has_ans[k]       )
  a__:					List[Any]      							=     num_no_ans
  a__:					Union[str, Any]      							=     cur_score
  a__:					Optional[Any]      							=     0.0
  a__:					str      							=     sorted(_SCREAMING_SNAKE_CASE		,					key=lambda _SCREAMING_SNAKE_CASE       : na_probs[k]       )
  for i, qid in enumerate(_SCREAMING_SNAKE_CASE       ):
    if qid not in scores:
      continue
    if qid_to_has_ans[qid]:
      a__:					Tuple      							=     scores[qid]
    else:
      if preds[qid]:
        a__:					Optional[Any]      							=     -1
      else:
        a__:					Optional[int]      							=     0
    cur_score += diff
    if cur_score > best_score:
      a__:					Dict      							=     cur_score
      a__:					Optional[int]      							=     na_probs[qid]
  return 100.0 * best_score / len(_SCREAMING_SNAKE_CASE       ), best_thresh







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->List[str]:
  a__							,   a__:					str      							=     find_best_thresh(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  a__							,   a__:					Optional[int]      							=     find_best_thresh(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  a__:					List[Any]      							=     best_exact
  a__:					Dict      							=     exact_thresh
  a__:					Optional[int]      							=     best_fa
  a__:					str      							=     fa_thresh







def 						__a       (     )     ->int:
  with open(OPTS.data_file       ) as f:
    a__:					Tuple      							=     json.load(_SCREAMING_SNAKE_CASE       )
    a__:					Union[str, Any]      							=     dataset_json['data']
  with open(OPTS.pred_file       ) as f:
    a__:					Dict      							=     json.load(_SCREAMING_SNAKE_CASE       )
  if OPTS.na_prob_file:
    with open(OPTS.na_prob_file       ) as f:
      a__:					Dict      							=     json.load(_SCREAMING_SNAKE_CASE       )
  else:
    a__:					Optional[Any]      							=     {k: 0.0 for k in preds}
  a__:					List[Any]      							=     make_qid_to_has_ans(_SCREAMING_SNAKE_CASE       )  # maps qid to True/False
  a__:					Optional[int]      							=     [k for k, v in qid_to_has_ans.items() if v]
  a__:					Union[str, Any]      							=     [k for k, v in qid_to_has_ans.items() if not v]
  a__							,   a__:					Optional[Any]      							=     get_raw_scores(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  a__:					Any      							=     apply_no_ans_threshold(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					OPTS.na_prob_thresh       )
  a__:					Dict      							=     apply_no_ans_threshold(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					OPTS.na_prob_thresh       )
  a__:					str      							=     make_eval_dict(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  if has_ans_qids:
    a__:					List[str]      							=     make_eval_dict(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					qid_list=_SCREAMING_SNAKE_CASE       )
    merge_eval(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					'HasAns'       )
  if no_ans_qids:
    a__:					Optional[Any]      							=     make_eval_dict(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					qid_list=_SCREAMING_SNAKE_CASE       )
    merge_eval(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					'NoAns'       )
  if OPTS.na_prob_file:
    find_all_best_thresh(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  if OPTS.na_prob_file and OPTS.out_image_dir:
    run_precision_recall_analysis(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					OPTS.out_image_dir       )
    histogram_na_prob(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					OPTS.out_image_dir		,					'hasAns'       )
    histogram_na_prob(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE		,					OPTS.out_image_dir		,					'noAns'       )
  if OPTS.out_file:
    with open(OPTS.out_file		,					'w'       ) as f:
      json.dump(_SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )
  else:
    print(json.dumps(_SCREAMING_SNAKE_CASE		,					indent=2       )       )


if __name__ == "__main__":
 lowercase__ 	=     parse_args()
 if OPTS.out_image_dir:
  import matplotlib

  matplotlib.use('Agg')
  import matplotlib.pyplot as plt
 main()


