



import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


__snake_case     :Optional[Any]			       ='\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'

__snake_case     :str			       ='\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


__snake_case     :List[str]			       ='\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=["About 95 species are currently accepted ."]\n    >>> predictions=["About 95 you now get in ."]\n    >>> references=[["About 95 species are currently known ."]]\n    >>> wiki_split = datasets.load_metric("wiki_split")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'






def  lowerCamelCase_	(      lowerCAmelCase__	:	Any				)       ->							Optional[Any]:

							'''simple docstring'''






							def remove_articles(lowerCAmelCase__	:	Union[str, Any]				):
														A      						=    re.compile(r'\b(a|an|the)\b'			,	re.UNICODE				)
														return re.sub(lowerCAmelCase__			,	' '			,	lowerCAmelCase__				)

							def white_space_fix(lowerCAmelCase__	:	str				):
														return " ".join(text.split()				)

							def remove_punc(lowerCAmelCase__	:	List[str]				):
														A      						=    set(string.punctuation				)
														return "".join(ch for ch in text if ch not in exclude				)

							def lower(lowerCAmelCase__	:	Any				):
														return text.lower()

							return white_space_fix(remove_articles(remove_punc(lower(lowerCAmelCase__				)				)				)				)






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	Optional[Any]				)       ->							List[str]:

							'''simple docstring'''






							return int(normalize_answer(lowerCAmelCase__				) == normalize_answer(lowerCAmelCase__				)				)






def  lowerCamelCase_	(      lowerCAmelCase__	:	Dict			,	lowerCAmelCase__	:	List[str]				)       ->							Tuple:

							'''simple docstring'''






							A      						=    [any(compute_exact(lowerCAmelCase__			,	lowerCAmelCase__				) for ref in refs				) for pred, refs in zip(lowerCAmelCase__			,	lowerCAmelCase__				)]
							return (sum(lowerCAmelCase__				) / len(lowerCAmelCase__				)) * 100






def  lowerCamelCase_	(      lowerCAmelCase__	:	List[Any]			,	lowerCAmelCase__	:	List[str]			,	lowerCAmelCase__	:	Optional[Any]			,	lowerCAmelCase__	:	List[Any]				)       ->							Any:

							'''simple docstring'''






							A      						=    [rgram for rgrams in rgramslist for rgram in rgrams]
							A      						=    Counter(lowerCAmelCase__				)

							A      						=    Counter(lowerCAmelCase__				)
							A      						=    Counter()
							for sgram, scount in sgramcounter.items():
														A      						=    scount * numref

							A      						=    Counter(lowerCAmelCase__				)
							A      						=    Counter()
							for cgram, ccount in cgramcounter.items():
														A      						=    ccount * numref

							# KEEP
							A      						=    sgramcounter_rep & cgramcounter_rep
							A      						=    keepgramcounter_rep & rgramcounter
							A      						=    sgramcounter_rep & rgramcounter

							A      						=    0
							A      						=    0
							for keepgram in keepgramcountergood_rep:
														keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
														# Fix an alleged bug [2] in the keep score computation.
														# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
														keeptmpscorea += keepgramcountergood_rep[keepgram]
							# Define 0/0=1 instead of 0 to give higher scores for predictions that match
							#      a target exactly.
							A      						=    1
							A      						=    1
							if len(lowerCAmelCase__				) > 0:
														A      						=    keeptmpscorea / len(lowerCAmelCase__				)
							if len(lowerCAmelCase__				) > 0:
														# Fix an alleged bug [2] in the keep score computation.
														# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
														A      						=    keeptmpscorea / sum(keepgramcounterall_rep.values()				)
							A      						=    0
							if keepscore_precision > 0 or keepscore_recall > 0:
														A      						=    2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

							# DELETION
							A      						=    sgramcounter_rep - cgramcounter_rep
							A      						=    delgramcounter_rep - rgramcounter
							A      						=    sgramcounter_rep - rgramcounter
							A      						=    0
							A      						=    0
							for delgram in delgramcountergood_rep:
														deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
														deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
							# Define 0/0=1 instead of 0 to give higher scores for predictions that match
							# a target exactly.
							A      						=    1
							if len(lowerCAmelCase__				) > 0:
														A      						=    deltmpscorea / len(lowerCAmelCase__				)

							# ADDITION
							A      						=    set(lowerCAmelCase__				) - set(lowerCAmelCase__				)
							A      						=    set(lowerCAmelCase__				) & set(lowerCAmelCase__				)
							A      						=    set(lowerCAmelCase__				) - set(lowerCAmelCase__				)

							A      						=    0
							for addgram in addgramcountergood:
														addtmpscore += 1

							# Define 0/0=1 instead of 0 to give higher scores for predictions that match
							# a target exactly.
							A      						=    1
							A      						=    1
							if len(lowerCAmelCase__				) > 0:
														A      						=    addtmpscore / len(lowerCAmelCase__				)
							if len(lowerCAmelCase__				) > 0:
														A      						=    addtmpscore / len(lowerCAmelCase__				)
							A      						=    0
							if addscore_precision > 0 or addscore_recall > 0:
														A      						=    2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

							return (keepscore, delscore_precision, addscore)






def  lowerCamelCase_	(      lowerCAmelCase__	:	Any			,	lowerCAmelCase__	:	List[Any]			,	lowerCAmelCase__	:	List[Any]				)       ->							Tuple:

							'''simple docstring'''






							A      						=    len(lowerCAmelCase__				)

							A      						=    ssent.split(' '				)
							A      						=    csent.split(' '				)
							A      						=    []
							A      						=    []
							A      						=    []
							A      						=    []
							A      						=    []
							A      						=    []

							A      						=    []
							A      						=    []
							A      						=    []
							A      						=    []
							for rsent in rsents:
														A      						=    rsent.split(' '				)
														A      						=    []
														A      						=    []
														A      						=    []
														ragramslist.append(lowerCAmelCase__				)
														for i in range(0			,	len(lowerCAmelCase__				) - 1				):
																					if i < len(lowerCAmelCase__				) - 1:
																												A      						=    ragrams[i] + ' ' + ragrams[i + 1]
																												ragrams.append(lowerCAmelCase__				)
																					if i < len(lowerCAmelCase__				) - 2:
																												A      						=    ragrams[i] + ' ' + ragrams[i + 1] + ' ' + ragrams[i + 2]
																												ragrams.append(lowerCAmelCase__				)
																					if i < len(lowerCAmelCase__				) - 3:
																												A      						=    ragrams[i] + ' ' + ragrams[i + 1] + ' ' + ragrams[i + 2] + ' ' + ragrams[i + 3]
																												ragrams.append(lowerCAmelCase__				)
														ragramslist.append(lowerCAmelCase__				)
														ragramslist.append(lowerCAmelCase__				)
														ragramslist.append(lowerCAmelCase__				)

							for i in range(0			,	len(lowerCAmelCase__				) - 1				):
														if i < len(lowerCAmelCase__				) - 1:
																					A      						=    sagrams[i] + ' ' + sagrams[i + 1]
																					sagrams.append(lowerCAmelCase__				)
														if i < len(lowerCAmelCase__				) - 2:
																					A      						=    sagrams[i] + ' ' + sagrams[i + 1] + ' ' + sagrams[i + 2]
																					sagrams.append(lowerCAmelCase__				)
														if i < len(lowerCAmelCase__				) - 3:
																					A      						=    sagrams[i] + ' ' + sagrams[i + 1] + ' ' + sagrams[i + 2] + ' ' + sagrams[i + 3]
																					sagrams.append(lowerCAmelCase__				)

							for i in range(0			,	len(lowerCAmelCase__				) - 1				):
														if i < len(lowerCAmelCase__				) - 1:
																					A      						=    cagrams[i] + ' ' + cagrams[i + 1]
																					cagrams.append(lowerCAmelCase__				)
														if i < len(lowerCAmelCase__				) - 2:
																					A      						=    cagrams[i] + ' ' + cagrams[i + 1] + ' ' + cagrams[i + 2]
																					cagrams.append(lowerCAmelCase__				)
														if i < len(lowerCAmelCase__				) - 3:
																					A      						=    cagrams[i] + ' ' + cagrams[i + 1] + ' ' + cagrams[i + 2] + ' ' + cagrams[i + 3]
																					cagrams.append(lowerCAmelCase__				)

							((A)						,   (A)						,   (A))      						=    SARIngram(lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__				)
							((A)						,   (A)						,   (A))      						=    SARIngram(lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__				)
							((A)						,   (A)						,   (A))      						=    SARIngram(lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__				)
							((A)						,   (A)						,   (A))      						=    SARIngram(lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__				)
							A      						=    sum([keepascore, keepascore, keepascore, keepascore]				) / 4
							A      						=    sum([delascore, delascore, delascore, delascore]				) / 4
							A      						=    sum([addascore, addascore, addascore, addascore]				) / 4
							A      						=    (avgkeepscore + avgdelscore + avgaddscore) / 3
							return finalscore






def  lowerCamelCase_	(      lowerCAmelCase__	:	Union[str, Any]			,	lowerCAmelCase__	:	bool = True			,	lowerCAmelCase__	:	str = "13a"			,	lowerCAmelCase__	:	bool = True				)       ->							Optional[int]:

							'''simple docstring'''






							if lowercase:
														A      						=    sentence.lower()

							if tokenizer in ["13a", "intl"]:
														if version.parse(sacrebleu.__version__				).major >= 2:
																					A      						=    sacrebleu.metrics.bleu._get_tokenizer(lowerCAmelCase__				)()(lowerCAmelCase__				)
														else:
																					A      						=    sacrebleu.TOKENIZERS[tokenizer]()(lowerCAmelCase__				)
							elif tokenizer == "moses":
														A      						=    sacremoses.MosesTokenizer().tokenize(lowerCAmelCase__			,	return_str=lowerCAmelCase__			,	escape=lowerCAmelCase__				)
							elif tokenizer == "penn":
														A      						=    sacremoses.MosesTokenizer().penn_tokenize(lowerCAmelCase__			,	return_str=lowerCAmelCase__				)
							else:
														A      						=    sentence

							if not return_str:
														A      						=    normalized_sent.split()

							return normalized_sent






def  lowerCamelCase_	(      lowerCAmelCase__	:	Tuple			,	lowerCAmelCase__	:	Tuple			,	lowerCAmelCase__	:	List[str]				)       ->							List[Any]:

							'''simple docstring'''






							if not (len(lowerCAmelCase__				) == len(lowerCAmelCase__				) == len(lowerCAmelCase__				)):
														raise ValueError('Sources length must match predictions and references lengths.'				)
							A      						=    0
							for src, pred, refs in zip(lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__				):
														sari_score += SARIsent(normalize(lowerCAmelCase__				)			,	normalize(lowerCAmelCase__				)			,	[normalize(lowerCAmelCase__				) for sent in refs]				)
							A      						=    sari_score / len(lowerCAmelCase__				)
							return 100 * sari_score






def  lowerCamelCase_	(      lowerCAmelCase__	:	List[str]			,	lowerCAmelCase__	:	int			,	lowerCAmelCase__	:	str="exp"			,	lowerCAmelCase__	:	Union[str, Any]=None			,	lowerCAmelCase__	:	List[str]=False			,	lowerCAmelCase__	:	Any=False			,	lowerCAmelCase__	:	Dict=False			,	)       ->							str:

							'''simple docstring'''






							A      						=    len(references[0]				)
							if any(len(lowerCAmelCase__				) != references_per_prediction for refs in references				):
														raise ValueError('Sacrebleu requires the same number of references for each prediction'				)
							A      						=    [[refs[i] for refs in references] for i in range(lowerCAmelCase__				)]
							A      						=    sacrebleu.corpus_bleu(
							    lowerCAmelCase__			,	lowerCAmelCase__			,	smooth_method=lowerCAmelCase__			,	smooth_value=lowerCAmelCase__			,	force=lowerCAmelCase__			,	lowercase=lowerCAmelCase__			,	use_effective_order=lowerCAmelCase__			,	)
							return output.score



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,				_KWARGS_DESCRIPTION       )
class        lowerCAmelCase__					(  datasets.Metric       ):


				def __UpperCamelCase						(							self      :  int       )		->     List[str]:
											return datasets.MetricInfo(
											    description=_DESCRIPTION						, citation=_CITATION						, inputs_description=_KWARGS_DESCRIPTION						, features=datasets.Features(
											        {
											            'predictions': datasets.Value('string'						, id='sequence'       ),
											            'references': datasets.Sequence(datasets.Value('string'						, id='sequence'       )						, id='references'       ),
											        }       )						, codebase_urls=[
											        'https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py',
											        'https://github.com/cocoxu/simplification/blob/master/SARI.py',
											        'https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py',
											        'https://github.com/mjpost/sacreBLEU',
											    ]						, reference_urls=[
											        'https://www.aclweb.org/anthology/Q16-1029.pdf',
											        'https://github.com/mjpost/sacreBLEU',
											        'https://en.wikipedia.org/wiki/BLEU',
											        'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213',
											    ]						, )


				def __UpperCamelCase						(							self      :  Optional[Any]						, __UpperCamelCase      :  Tuple						, __UpperCamelCase      :  Tuple						, __UpperCamelCase      :  Any       )		->     str:
											A      						=    {}
											result.update({'sari': compute_sari(sources=__UpperCamelCase						, predictions=__UpperCamelCase						, references=__UpperCamelCase       )}       )
											result.update({'sacrebleu': compute_sacrebleu(predictions=__UpperCamelCase						, references=__UpperCamelCase       )}       )
											result.update({'exact': compute_em(predictions=__UpperCamelCase						, references=__UpperCamelCase       )}       )
											return result




from ...configuration_utils import PretrainedConfig
from ...utils import logging


__snake_case     :List[str]			       =logging.get_logger(__name__)

__snake_case     :int			       ={'openai-gpt': 'https://huggingface.co/openai-gpt/resolve/main/config.json'}



class        lowerCAmelCase__					(  _lowerCamelCase       ):
				A_   :     Optional[Any]								=     'openai-gpt'
				A_   :     Any								=     {
				    'max_position_embeddings': 'n_positions',
				    'hidden_size': 'n_embd',
				    'num_attention_heads': 'n_head',
				    'num_hidden_layers': 'n_layer',
				}


				def __init__(							self      :  List[Any]						, __UpperCamelCase      :  List[str]=40_478						, __UpperCamelCase      :  List[Any]=512						, __UpperCamelCase      :  List[Any]=768						, __UpperCamelCase      :  Optional[int]=12						, __UpperCamelCase      :  Dict=12						, __UpperCamelCase      :  List[str]="gelu"						, __UpperCamelCase      :  str=0.1						, __UpperCamelCase      :  Optional[Any]=0.1						, __UpperCamelCase      :  Union[str, Any]=0.1						, __UpperCamelCase      :  List[str]=1e-5						, __UpperCamelCase      :  List[Any]=0.0_2						, __UpperCamelCase      :  str="cls_index"						, __UpperCamelCase      :  int=True						, __UpperCamelCase      :  int=None						, __UpperCamelCase      :  Optional[int]=True						, __UpperCamelCase      :  Tuple=0.1						, **__UpperCamelCase      :  List[Any]						, )		->     List[str]:
											A      						=    vocab_size
											A      						=    n_positions
											A      						=    n_embd
											A      						=    n_layer
											A      						=    n_head
											A      						=    afn
											A      						=    resid_pdrop
											A      						=    embd_pdrop
											A      						=    attn_pdrop
											A      						=    layer_norm_epsilon
											A      						=    initializer_range
											A      						=    summary_type
											A      						=    summary_use_proj
											A      						=    summary_activation
											A      						=    summary_first_dropout
											A      						=    summary_proj_to_labels
											super().__init__(**__UpperCamelCase       )