




import argparse
import json
import re
import string
import sys
from collections import Counter
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE ):
			'''simple docstring'''

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

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

			def remove_punc(SCREAMING_SNAKE_CASE ):
						SCREAMING_SNAKE_CASE     =       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(_UpperCamelCase ) ) ) )
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE     =       normalize_answer(_UpperCamelCase ).split()
			SCREAMING_SNAKE_CASE     =       normalize_answer(_UpperCamelCase ).split()
			SCREAMING_SNAKE_CASE     =       Counter(_UpperCamelCase ) & Counter(_UpperCamelCase )
			SCREAMING_SNAKE_CASE     =       sum(common.values() )
			if num_same == 0:
						return 0
			SCREAMING_SNAKE_CASE     =       1.0 * num_same / len(_UpperCamelCase )
			SCREAMING_SNAKE_CASE     =       1.0 * num_same / len(_UpperCamelCase )
			SCREAMING_SNAKE_CASE     =       (2 * precision * recall) / (precision + recall)
			return fa
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			return normalize_answer(_UpperCamelCase ) == normalize_answer(_UpperCamelCase )
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE     =       []
			for ground_truth in ground_truths:
						SCREAMING_SNAKE_CASE     =       metric_fn(_UpperCamelCase       ,						_UpperCamelCase )
						scores_for_ground_truths.append(_UpperCamelCase )
			return max(_UpperCamelCase )
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE     =       SCREAMING_SNAKE_CASE     =       SCREAMING_SNAKE_CASE     =       0
			for article in dataset:
						for paragraph in article["paragraphs"]:
									for qa in paragraph["qas"]:
												total += 1
												if qa["id"] not in predictions:
															SCREAMING_SNAKE_CASE     =       """Unanswered question """ + qa["""id"""] + """ will receive score 0."""
															print(_UpperCamelCase       ,						file=sys.stderr )
															continue
												SCREAMING_SNAKE_CASE     =       [x["""text"""] for x in qa["""answers"""]]
												SCREAMING_SNAKE_CASE     =       predictions[qa["""id"""]]
												exact_match += metric_max_over_ground_truths(_UpperCamelCase       ,						_UpperCamelCase       ,						_UpperCamelCase )
												fa += metric_max_over_ground_truths(_UpperCamelCase       ,						_UpperCamelCase       ,						_UpperCamelCase )

			SCREAMING_SNAKE_CASE     =       100.0 * exact_match / total
			SCREAMING_SNAKE_CASE     =       100.0 * fa / total

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


if __name__ == "__main__":
		__A    :				Tuple    						=	"""1.1"""
		__A    :				List[Any]    						=	argparse.ArgumentParser(description="""Evaluation for SQuAD """ + expected_version)
		parser.add_argument("""dataset_file""", help="""Dataset file""")
		parser.add_argument("""prediction_file""", help="""Prediction File""")
		__A    :				Optional[int]    						=	parser.parse_args()
		with open(args.dataset_file) as dataset_file:
				__A    :				List[Any]    						=	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,
						)
				__A    :				Union[str, Any]    						=	dataset_json["""data"""]
		with open(args.prediction_file) as prediction_file:
				__A    :				Union[str, Any]    						=	json.load(prediction_file)
		print(json.dumps(evaluate(dataset, predictions)))










"""simple docstring"""







import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


__a      			= [nn.LayerNorm]

__a      			= logging.get_logger(__name__)

__a      			= version.parse(version.parse(torch.__version__).base_version)

__a      			= parsed_torch_version_base >= version.parse("2.0")
__a      			= parsed_torch_version_base >= version.parse("1.12")
__a      			= parsed_torch_version_base >= version.parse("1.11")
__a      			= parsed_torch_version_base < version.parse("1.11")






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      self			):





						"""simple docstring"""

						from torch import _softmax_backward_data

						if is_torch_less_than_1_11:
												return _softmax_backward_data(_UpperCamelCase						,      _UpperCamelCase						,      parent.dim						,      self			)
						else:
												return _softmax_backward_data(_UpperCamelCase						,      _UpperCamelCase						,      parent.dim						,      self.dtype			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase = 0			):





						"""simple docstring"""

						UpperCAmelCase__												=     index.to(layer.weight.device			)
						UpperCAmelCase__												=     layer.weight.index_select(_UpperCamelCase						,      _UpperCamelCase			).clone().detach()
						if layer.bias is not None:
												if dim == 1:
																		UpperCAmelCase__												=     layer.bias.clone().detach()
												else:
																		UpperCAmelCase__												=     layer.bias[index].clone().detach()
						UpperCAmelCase__												=     list(layer.weight.size()			)
						UpperCAmelCase__												=     len(_UpperCamelCase			)
						UpperCAmelCase__												=     nn.Linear(new_size[1]						,      new_size[0]						,      bias=layer.bias is not None			).to(layer.weight.device			)
						UpperCAmelCase__												=     False
						new_layer.weight.copy_(W.contiguous()			)
						UpperCAmelCase__												=     True
						if layer.bias is not None:
												UpperCAmelCase__												=     False
												new_layer.bias.copy_(b.contiguous()			)
												UpperCAmelCase__												=     True
						return new_layer
class 				lowerCamelCase							(      nn.Module			):


							"""simple docstring"""






							def __init__(    self			:  str		,			lowerCamelCase_			:  Any		,			lowerCamelCase_			:  Dict					):
													super().__init__()
													UpperCAmelCase__												=     nf
													UpperCAmelCase__												=     nn.Parameter(torch.empty(lowerCamelCase_		,			lowerCamelCase_					)					)
													UpperCAmelCase__												=     nn.Parameter(torch.zeros(lowerCamelCase_					)					)
													nn.init.normal_(self.weight		,			std=0.02					)






							def        lowerCAmelCase  (    self			:  Any		,			lowerCamelCase_			:  Tuple					):
													UpperCAmelCase__												=     x.size()[:-1] + (self.nf,)
													UpperCAmelCase__												=     torch.addmm(self.bias		,			x.view(-1		,			x.size(-1					)					)		,			self.weight					)
													UpperCAmelCase__												=     x.view(lowerCamelCase_					)
													return x






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase = 1			):





						"""simple docstring"""

						UpperCAmelCase__												=     index.to(layer.weight.device			)
						UpperCAmelCase__												=     layer.weight.index_select(_UpperCamelCase						,      _UpperCamelCase			).clone().detach()
						if dim == 0:
												UpperCAmelCase__												=     layer.bias.clone().detach()
						else:
												UpperCAmelCase__												=     layer.bias[index].clone().detach()
						UpperCAmelCase__												=     list(layer.weight.size()			)
						UpperCAmelCase__												=     len(_UpperCamelCase			)
						UpperCAmelCase__												=     ConvaD(new_size[1]						,      new_size[0]			).to(layer.weight.device			)
						UpperCAmelCase__												=     False
						new_layer.weight.copy_(W.contiguous()			)
						UpperCAmelCase__												=     True
						UpperCAmelCase__												=     False
						new_layer.bias.copy_(b.contiguous()			)
						UpperCAmelCase__												=     True
						return new_layer






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase = None			):





						"""simple docstring"""

						if isinstance(_UpperCamelCase						,      nn.Linear			):
												return prune_linear_layer(_UpperCamelCase						,      _UpperCamelCase						,      dim=0 if dim is None else dim			)
						elif isinstance(_UpperCamelCase						,      _UpperCamelCase			):
												return prune_convad_layer(_UpperCamelCase						,      _UpperCamelCase						,      dim=1 if dim is None else dim			)
						else:
												raise ValueError(F"""Can't prune layer of class {layer.__class__}"""			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      *_UpperCamelCase			):





						"""simple docstring"""

						assert len(_UpperCamelCase			) > 0, F"""{input_tensors} has to be a tuple/list of tensors"""

						# inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
						UpperCAmelCase__												=     len(inspect.signature(_UpperCamelCase			).parameters			)
						if num_args_in_forward_chunk_fn != len(_UpperCamelCase			):
												raise ValueError(
												    F"""forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(_UpperCamelCase			)} input """
												    '''tensors are given'''			)

						if chunk_size > 0:
												UpperCAmelCase__												=     input_tensors[0].shape[chunk_dim]
												for input_tensor in input_tensors:
																		if input_tensor.shape[chunk_dim] != tensor_shape:
																								raise ValueError(
																								    F"""All input tenors have to be of the same shape: {tensor_shape}, """
																								    F"""found shape {input_tensor.shape[chunk_dim]}"""			)

												if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
																		raise ValueError(
																		    F"""The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk """
																		    F"""size {chunk_size}"""			)

												UpperCAmelCase__												=     input_tensors[0].shape[chunk_dim] // chunk_size

												# chunk input tensor into tuples
												UpperCAmelCase__												=     tuple(input_tensor.chunk(_UpperCamelCase						,      dim=_UpperCamelCase			) for input_tensor in input_tensors			)
												# apply forward fn to every tuple
												UpperCAmelCase__												=     tuple(forward_fn(*_UpperCamelCase			) for input_tensors_chunk in zip(*_UpperCamelCase			)			)
												# concatenate output at same dimension
												return torch.cat(_UpperCamelCase						,      dim=_UpperCamelCase			)

						return forward_fn(*_UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase			):





						"""simple docstring"""

						UpperCAmelCase__												=     torch.ones(_UpperCamelCase						,      _UpperCamelCase			)
						UpperCAmelCase__												=     set(_UpperCamelCase			) - already_pruned_heads  # Convert to set and remove already pruned heads
						for head in heads:
												# Compute how many pruned heads are before the head and move the index accordingly
												UpperCAmelCase__												=     head - sum(1 if h < head else 0 for h in already_pruned_heads			)
												UpperCAmelCase__												=     0
						UpperCAmelCase__												=     mask.view(-1			).contiguous().eq(1			)
						UpperCAmelCase__												=     torch.arange(len(_UpperCamelCase			)			)[mask].long()
						return heads, index






def        a__			(							*_UpperCamelCase						,      _UpperCamelCase = None			):





						"""simple docstring"""

						return torch.meshgrid(*_UpperCamelCase						,      indexing=_UpperCamelCase			)






def        a__			(							_UpperCamelCase			):





						"""simple docstring"""

						return tensor.device, storage_ptr(_UpperCamelCase			), storage_size(_UpperCamelCase			)