code: 
  
  
  
  
  
  '''simple docstring'''
  
  import argparse
  import json
  import re
  import string
  import sys
  from collections import Counter
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      str ):
  
      def remove_articles(_lowerCamelCase      :      Optional[Any] ):
          return re.sub(r"\b(a|an|the)\b"		, " "		, _lowerCamelCase )
  
      def white_space_fix(_lowerCamelCase      :      int ):
          return " ".join(text.split() )
  
      def remove_punc(_lowerCamelCase      :      Dict ):
          A__       =    set(string.punctuation )
          return "".join(ch for ch in text if ch not in exclude )
  
      def lower(_lowerCamelCase      :      Tuple ):
          return text.lower()
  
      return white_space_fix(remove_articles(remove_punc(lower(_lowerCamelCase ) ) ) )
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      Union[str, Any]		, _lowerCamelCase      :      int ):
      A__       =    normalize_answer(_lowerCamelCase ).split()
      A__       =    normalize_answer(_lowerCamelCase ).split()
      A__       =    Counter(_lowerCamelCase ) & Counter(_lowerCamelCase )
      A__       =    sum(common.values() )
      if num_same == 0:
          return 0
      A__       =    1.0 * num_same / len(_lowerCamelCase )
      A__       =    1.0 * num_same / len(_lowerCamelCase )
      A__       =    (2 * precision * recall) / (precision + recall)
      return fa
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      str		, _lowerCamelCase      :      Any ):
      return normalize_answer(_lowerCamelCase ) == normalize_answer(_lowerCamelCase )
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      str		, _lowerCamelCase      :      Optional[int]		, _lowerCamelCase      :      str ):
      A__       =    []
      for ground_truth in ground_truths:
          A__       =    metric_fn(_lowerCamelCase		, _lowerCamelCase )
          scores_for_ground_truths.append(_lowerCamelCase )
      return max(_lowerCamelCase )
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      str		, _lowerCamelCase      :      Optional[int] ):
      A__       =    A__       =    A__       =    0
      for article in dataset:
          for paragraph in article["paragraphs"]:
              for qa in paragraph["qas"]:
                  total += 1
                  if qa["id"] not in predictions:
                      A__       =    "Unanswered question " + qa["id"] + " will receive score 0."
                      print(_lowerCamelCase		, file=sys.stderr )
                      continue
                  A__       =    [x["text"] for x in qa["answers"]]
                  A__       =    predictions[qa["id"]]
                  exact_match += metric_max_over_ground_truths(_lowerCamelCase		, _lowerCamelCase		, _lowerCamelCase )
                  fa += metric_max_over_ground_truths(_lowerCamelCase		, _lowerCamelCase		, _lowerCamelCase )
  
      A__       =    1_0_0.0 * exact_match / total
      A__       =    1_0_0.0 * fa / total
  
      return {"exact_match": exact_match, "f1": fa}
  
  
  if __name__ == "__main__":
    __lowerCAmelCase							:			List[Any]				="1.1"
    __lowerCAmelCase							:			Tuple				=argparse.ArgumentParser(description="Evaluation for SQuAD " + expected_version)
    parser.add_argument("dataset_file", help="Dataset file")
    parser.add_argument("prediction_file", help="Prediction File")
    __lowerCAmelCase							:			str				=parser.parse_args()
    with open(args.dataset_file) as dataset_file:
      __lowerCAmelCase							:			Optional[int]				=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,
        )
      __lowerCAmelCase							:			List[str]				=dataset_json["data"]
    with open(args.prediction_file) as prediction_file:
      __lowerCAmelCase							:			Optional[Any]				=json.load(prediction_file)
    print(json.dumps(evaluate(dataset, predictions)))
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import collections
  
  from .utils import ExplicitEnum, is_torch_available, logging
  
  
  if is_torch_available():
    import torch
  
  
  __lowerCAmelCase							:			Optional[int]				=logging.get_logger(__name__)
  
  
  
  
  
  
  class      UpperCAmelCase			:
   def __init__(       self   :Optional[int]		, lowercase_   :Any		, lowercase_   :Any=21		, lowercase_   :Any=[]		, lowercase_   :Dict=None							)->							Tuple:
       A__       =    model
       A__       =    trace_batch_nums
       A__       =    abort_after_batch_num
  
       # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
       A__       =    collections.deque([]		, lowercase_							)
       A__       =    []
       A__       =    0
       A__       =    0
       A__       =    False
       A__       =    "                 "
  
       self.analyse_model()
  
       self.register_forward_hook()
   def   UpperCAmelCase_							(       self   :Any		, lowercase_   :Any=None							)->							Optional[Any]:
       if frame is not None:
           self.expand_frame(lowercase_							)
       self.frames.append("\n".join(self.frame							)							)
       A__       =    []  # start a new frame
   def   UpperCAmelCase_							(       self   :Union[str, Any]		, lowercase_   :Dict							)->							List[str]:
       self.frame.append(lowercase_							)
   def   UpperCAmelCase_							(       self   :int							)->							Dict:
       print("\n".join(self.frames							)							)
       A__       =    []
   def   UpperCAmelCase_							(       self   :str							)->							Union[str, Any]:
       A__       =    []
   def   UpperCAmelCase_							(       self   :List[str]							)->							Optional[Any]:
       print(F"\nDetected inf/nan during batch_number={self.batch_number}"							)
       print(F"Last {len(self.frames							)} forward frames:"							)
       print(F"{'abs min':8} {'abs max':8} metadata"							)
       print("\n".join(self.frames							)							)
       print("\n\n"							)
       A__       =    []
   def   UpperCAmelCase_							(       self   :Any							)->							Optional[Any]:
       # extract the fully qualified module names, to be able to report at run time. e.g.:
       # encoder.block.2.layer.0.SelfAttention.o
       #
       # for shared weights only the first shared module name will be registered
       A__       =    {m: name for name, m in self.model.named_modules()}
       # self.longest_module_name = max(len(v) for v in self.module_names.values())
   def   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :Dict		, lowercase_   :Any							)->							str:
       if torch.is_tensor(lowercase_							):
           self.expand_frame(get_abs_min_max(lowercase_		, lowercase_							)							)
           if detect_overflow(lowercase_		, lowercase_							):
               A__       =    True
       elif var is None:
           self.expand_frame(F"{'None':>17} {ctx}"							)
       else:
           self.expand_frame(F"{'not a tensor':>17} {ctx}"							)
   def   UpperCAmelCase_							(       self   :Union[str, Any]							)->							str:
       self.expand_frame(F"\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"							)
       self.expand_frame(F"{'abs min':8} {'abs max':8} metadata"							)
   def   UpperCAmelCase_							(       self   :int							)->							int:
       self.expand_frame(F"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"							)
   def   UpperCAmelCase_							(       self   :Optional[int]		, lowercase_   :Dict		, lowercase_   :Dict		, lowercase_   :str							)->							int:
       self.expand_frame(F"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"							)
  
       # params
       for name, p in module.named_parameters(recurse=lowercase_							):
           self.analyse_variable(lowercase_		, lowercase_							)
  
       # inputs
       if isinstance(lowercase_		, lowercase_							):
           for i, x in enumerate(lowercase_							):
               self.analyse_variable(lowercase_		, F"input[{i}]"							)
       else:
           self.analyse_variable(lowercase_		, "input"							)
  
       # outputs
       if isinstance(lowercase_		, lowercase_							):
           for i, x in enumerate(lowercase_							):
               # possibly a tuple of tuples
               if isinstance(lowercase_		, lowercase_							):
                   for j, y in enumerate(lowercase_							):
                       self.analyse_variable(lowercase_		, F"output[{i}][{j}]"							)
               else:
                   self.analyse_variable(lowercase_		, F"output[{i}]"							)
       else:
           self.analyse_variable(lowercase_		, "output"							)
  
       self.save_frame()
   def   UpperCAmelCase_							(       self   :Any							)->							int:
       self.model.apply(self._register_forward_hook							)
   def   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :Optional[int]							)->							Tuple:
       module.register_forward_hook(self.forward_hook							)
  
  
  
   def   UpperCAmelCase_							(       self   :List[str]		, lowercase_   :int		, lowercase_   :Optional[Any]		, lowercase_   :Dict							)->							Union[str, Any]:
       # - input is a tuple of packed inputs (could be non-Tensors)
       # - output could be a Tensor or a tuple of Tensors and non-Tensors
  
       A__       =    False
  
       A__       =    True if self.batch_number in self.trace_batch_nums else False
       if trace_mode:
           self.reset_saved_frames()
  
       if self.total_calls == 0:
           self.batch_start_frame()
       self.total_calls += 1
  
       # count batch numbers - the very first forward hook of the batch will be called when the
       # batch completes - i.e. it gets called very last - we know this batch has finished
       if module == self.model:
           self.batch_number += 1
           A__       =    True
  
       self.create_frame(lowercase_		, lowercase_		, lowercase_							)
  
       # if last_frame_of_batch:
       #     self.batch_end_frame()
  
       if trace_mode:
           self.trace_frames()
  
       if last_frame_of_batch:
           self.batch_start_frame()
  
       if self.detected_overflow and not trace_mode:
           self.dump_saved_frames()
  
           # now we can abort, as it's pointless to continue running
           raise ValueError(
               "DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. "
               "Please scroll up above this traceback to see the activation values prior to this event."							)
  
       # abort after certain batch if requested to do so
       if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
           raise ValueError(
               F"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"
               F" `abort_after_batch_num={self.abort_after_batch_num}` arg"							)
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      Dict		, _lowerCamelCase      :      int ):
      A__       =    var.abs()
      return F"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      Tuple		, _lowerCamelCase      :      Optional[int] ):
      A__       =    False
      if torch.isnan(_lowerCamelCase ).any().item():
          A__       =    True
          print(F"{ctx} has nans" )
      if torch.isinf(_lowerCamelCase ).any().item():
          A__       =    True
          print(F"{ctx} has infs" )
  
      # if needed to monitor large elements can enable the following
      if 0:  # and detected:
          A__       =    var[torch.ge(var.abs()		, 1_00 )]
          if naaa.numel() > 0:
              print(F"{ctx}:  n100={naaa.numel()}" )
          A__       =    var[torch.ge(var.abs()		, 10_00 )]
          if naaaa.numel() > 0:
              print(F"{ctx}: n1000={naaaa.numel()}" )
          A__       =    var[torch.ge(var.abs()		, 1_00_00 )]
          if naaaaa.numel() > 0:
              print(F"{ctx}: n10000={naaaaa.numel()}" )
  
      if 0:
          print(F"min={var.min():9.2e} max={var.max():9.2e}" )
  
      if 0:
          print(F"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})" )
  
      return detected
  
  
  
  
  
  
  class      UpperCAmelCase			( UpperCamelCase__       ):
   __lowercase     	=       """underflow_overflow"""
   __lowercase     	=       """tpu_metrics_debug"""
  
  
  
  