'''simple docstring'''




import warnings
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


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

_lowercase						: int						=						{
    "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/config.json",
    # See all BART models at https://huggingface.co/models?filter=bart
}





class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''bart'''
			UpperCamelCase__				=       ['''past_key_values''']
			UpperCamelCase__				=       {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}







			def __init__(	self				:  Union[str, Any]				,			lowercase_				:  str=50265				,			lowercase_				:  Union[str, Any]=1024				,			lowercase_				:  Tuple=12				,			lowercase_				:  Tuple=4096				,			lowercase_				:  Any=16				,			lowercase_				:  Dict=12				,			lowercase_				:  Tuple=4096				,			lowercase_				:  Dict=16				,			lowercase_				:  List[Any]=0.0				,			lowercase_				:  int=0.0				,			lowercase_				:  List[str]="gelu"				,			lowercase_				:  List[Any]=1024				,			lowercase_				:  Optional[Any]=0.1				,			lowercase_				:  str=0.0				,			lowercase_				:  Dict=0.0				,			lowercase_				:  str=0.02				,			lowercase_				:  Tuple=0.0				,			lowercase_				:  int=False				,			lowercase_				:  List[str]=True				,			lowercase_				:  Optional[int]=3				,			lowercase_				:  Any=1				,			lowercase_				:  List[Any]=0				,			lowercase_				:  List[str]=2				,			lowercase_				:  Tuple=True				,			lowercase_				:  Optional[int]=2				,			lowercase_				:  str=2				,			**lowercase_				:  Optional[Any]				,			):
										lowercase_					:			Optional[Any]										=       vocab_size
										lowercase_					:			Optional[int]										=       max_position_embeddings
										lowercase_					:			int										=       d_model
										lowercase_					:			str										=       encoder_ffn_dim
										lowercase_					:			Dict										=       encoder_layers
										lowercase_					:			str										=       encoder_attention_heads
										lowercase_					:			Optional[int]										=       decoder_ffn_dim
										lowercase_					:			Optional[int]										=       decoder_layers
										lowercase_					:			int										=       decoder_attention_heads
										lowercase_					:			str										=       dropout
										lowercase_					:			Optional[int]										=       attention_dropout
										lowercase_					:			Any										=       activation_dropout
										lowercase_					:			Optional[int]										=       activation_function
										lowercase_					:			Dict										=       init_std
										lowercase_					:			List[Any]										=       encoder_layerdrop
										lowercase_					:			Tuple										=       decoder_layerdrop
										lowercase_					:			Dict										=       classifier_dropout
										lowercase_					:			Optional[Any]										=       use_cache
										lowercase_					:			str										=       encoder_layers
										lowercase_					:			Optional[int]										=       scale_embedding  # scale factor will be sqrt(d_model) if True

										super().__init__(
										    num_labels=lowercase_				,			pad_token_id=lowercase_				,			bos_token_id=lowercase_				,			eos_token_id=lowercase_				,			is_encoder_decoder=lowercase_				,			decoder_start_token_id=lowercase_				,			forced_eos_token_id=lowercase_				,			**lowercase_				,			)

										# ensure backward compatibility for BART CNN models
										if self.forced_bos_token_id is None and kwargs.get("""force_bos_token_to_be_generated"""				,			lowercase_    ):
																	lowercase_					:			Optional[int]										=       self.bos_token_id
																	warnings.warn(
																	    f'''Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. '''
																	    """The config can simply be saved and uploaded again to be fixed."""    )





class     __magic_name__						(    _UpperCAmelCase):







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										if self.task in ["default", "seq2seq-lm"]:
																	lowercase_					:			Tuple										=       OrderedDict(
																	    [
																	        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
																	        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
																	    ]    )

																	if self.use_past:
																								lowercase_					:			Tuple										=       {0: """batch"""}
																								lowercase_					:			Union[str, Any]										=       {0: """batch""", 1: """past_decoder_sequence + sequence"""}
																	else:
																								lowercase_					:			List[Any]										=       {0: """batch""", 1: """decoder_sequence"""}
																								lowercase_					:			int										=       {0: """batch""", 1: """decoder_sequence"""}

																	if self.use_past:
																								self.fill_with_past_key_values_(lowercase_				,			direction="""inputs"""    )
										elif self.task == "causal-lm":
																	# TODO: figure this case out.
																	lowercase_					:			Union[str, Any]										=       OrderedDict(
																	    [
																	        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
																	        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
																	    ]    )
																	if self.use_past:
																								lowercase_						,						lowercase_					:			Any										=       self.num_layers
																								for i in range(lowercase_    ):
																															lowercase_					:			str										=       {0: """batch""", 2: """past_sequence + sequence"""}
																															lowercase_					:			Dict										=       {0: """batch""", 2: """past_sequence + sequence"""}
										else:
																	lowercase_					:			Optional[int]										=       OrderedDict(
																	    [
																	        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
																	        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
																	        ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}),
																	        ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}),
																	    ]    )

										return common_inputs







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[str]    ):
										if self.task in ["default", "seq2seq-lm"]:
																	lowercase_					:			Optional[int]										=       super().outputs
										else:
																	lowercase_					:			Dict										=       super(lowercase_				,			self    ).outputs
																	if self.use_past:
																								lowercase_						,						lowercase_					:			List[str]										=       self.num_layers
																								for i in range(lowercase_    ):
																															lowercase_					:			Tuple										=       {0: """batch""", 2: """past_sequence + sequence"""}
																															lowercase_					:			Optional[int]										=       {0: """batch""", 2: """past_sequence + sequence"""}
										return common_outputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any				,			lowercase_				:  PreTrainedTokenizer				,			lowercase_				:  int = -1				,			lowercase_				:  int = -1				,			lowercase_				:  bool = False				,			lowercase_				:  Optional[TensorType] = None				,			):
										lowercase_					:			Any										=       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    lowercase_				,			lowercase_				,			lowercase_				,			lowercase_				,			lowercase_    )

										# Generate decoder inputs
										lowercase_					:			Dict										=       seq_length if not self.use_past else 1
										lowercase_					:			Optional[Any]										=       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    lowercase_				,			lowercase_				,			lowercase_				,			lowercase_				,			lowercase_    )
										lowercase_					:			str										=       {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
										lowercase_					:			str										=       dict(**lowercase_				,			**lowercase_    )

										if self.use_past:
																	if not is_torch_available():
																								raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""    )
																	else:
																								import torch
																	lowercase_						,						lowercase_					:			Union[str, Any]										=       common_inputs["""input_ids"""].shape
																	lowercase_					:			Union[str, Any]										=       common_inputs["""decoder_input_ids"""].shape[1]
																	lowercase_						,						lowercase_					:			int										=       self.num_attention_heads
																	lowercase_					:			Optional[int]										=       (
																	    batch,
																	    num_encoder_attention_heads,
																	    encoder_seq_length,
																	    self._config.hidden_size // num_encoder_attention_heads,
																	)
																	lowercase_					:			List[str]										=       decoder_seq_length + 3
																	lowercase_					:			Union[str, Any]										=       (
																	    batch,
																	    num_decoder_attention_heads,
																	    decoder_past_length,
																	    self._config.hidden_size // num_decoder_attention_heads,
																	)

																	lowercase_					:			Tuple										=       torch.cat(
																	    [common_inputs["""decoder_attention_mask"""], torch.ones(lowercase_				,			lowercase_    )]				,			dim=1    )

																	lowercase_					:			int										=       []
																	# If the number of encoder and decoder layers are present in the model configuration, both are considered
																	lowercase_						,						lowercase_					:			int										=       self.num_layers
																	lowercase_					:			Optional[Any]										=       min(lowercase_				,			lowercase_    )
																	lowercase_					:			int										=       max(lowercase_				,			lowercase_    ) - min_num_layers
																	lowercase_					:			List[str]										=       """encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

																	for _ in range(lowercase_    ):
																								common_inputs["past_key_values"].append(
																								    (
																								        torch.zeros(lowercase_    ),
																								        torch.zeros(lowercase_    ),
																								        torch.zeros(lowercase_    ),
																								        torch.zeros(lowercase_    ),
																								    )    )
																	# TODO: test this.
																	lowercase_					:			Optional[int]										=       encoder_shape if remaining_side_name == """encoder""" else decoder_shape
																	for _ in range(lowercase_				,			lowercase_    ):
																								common_inputs["past_key_values"].append((torch.zeros(lowercase_    ), torch.zeros(lowercase_    ))    )
										return common_inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]				,			lowercase_				:  PreTrainedTokenizer				,			lowercase_				:  int = -1				,			lowercase_				:  int = -1				,			lowercase_				:  bool = False				,			lowercase_				:  Optional[TensorType] = None				,			):
										lowercase_					:			Optional[Any]										=       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    lowercase_				,			lowercase_				,			lowercase_				,			lowercase_				,			lowercase_    )

										if self.use_past:
																	if not is_torch_available():
																								raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""    )
																	else:
																								import torch
																	lowercase_						,						lowercase_					:			List[str]										=       common_inputs["""input_ids"""].shape
																	# Not using the same length for past_key_values
																	lowercase_					:			Any										=       seqlen + 2
																	lowercase_						,						lowercase_					:			Optional[int]										=       self.num_layers
																	lowercase_						,						lowercase_					:			Union[str, Any]										=       self.num_attention_heads
																	lowercase_					:			str										=       (
																	    batch,
																	    num_encoder_attention_heads,
																	    past_key_values_length,
																	    self._config.hidden_size // num_encoder_attention_heads,
																	)

																	lowercase_					:			Optional[int]										=       common_inputs["""attention_mask"""].dtype
																	lowercase_					:			List[str]										=       torch.cat(
																	    [common_inputs["""attention_mask"""], torch.ones(lowercase_				,			lowercase_				,			dtype=lowercase_    )]				,			dim=1    )
																	lowercase_					:			Optional[Any]										=       [
																	    (torch.zeros(lowercase_    ), torch.zeros(lowercase_    )) for _ in range(lowercase_    )
																	]
										return common_inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[str]				,			lowercase_				:  PreTrainedTokenizer				,			lowercase_				:  int = -1				,			lowercase_				:  int = -1				,			lowercase_				:  bool = False				,			lowercase_				:  Optional[TensorType] = None				,			):
										# Copied from OnnxConfig.generate_dummy_inputs
										# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
										# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
										lowercase_					:			str										=       compute_effective_axis_dimension(
										    lowercase_				,			fixed_dimension=OnnxConfig.default_fixed_batch				,			num_token_to_add=0    )

										# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
										lowercase_					:			Optional[int]										=       tokenizer.num_special_tokens_to_add(lowercase_    )
										lowercase_					:			Union[str, Any]										=       compute_effective_axis_dimension(
										    lowercase_				,			fixed_dimension=OnnxConfig.default_fixed_sequence				,			num_token_to_add=lowercase_    )

										# Generate dummy inputs according to compute batch and sequence
										lowercase_					:			Optional[Any]										=       [""" """.join([tokenizer.unk_token]    ) * seq_length] * batch_size
										lowercase_					:			List[Any]										=       dict(tokenizer(lowercase_				,			return_tensors=lowercase_    )    )
										return common_inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]				,			lowercase_				:  PreTrainedTokenizer				,			lowercase_				:  int = -1				,			lowercase_				:  int = -1				,			lowercase_				:  bool = False				,			lowercase_				:  Optional[TensorType] = None				,			):
										if self.task in ["default", "seq2seq-lm"]:
																	lowercase_					:			Tuple										=       self._generate_dummy_inputs_for_default_and_seqaseq_lm(
																	    lowercase_				,			batch_size=lowercase_				,			seq_length=lowercase_				,			is_pair=lowercase_				,			framework=lowercase_    )

										elif self.task == "causal-lm":
																	lowercase_					:			str										=       self._generate_dummy_inputs_for_causal_lm(
																	    lowercase_				,			batch_size=lowercase_				,			seq_length=lowercase_				,			is_pair=lowercase_				,			framework=lowercase_    )
										else:
																	lowercase_					:			Tuple										=       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
																	    lowercase_				,			batch_size=lowercase_				,			seq_length=lowercase_				,			is_pair=lowercase_				,			framework=lowercase_    )

										return common_inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  str				,			lowercase_				:  str				,			lowercase_				:  Optional[int]				,			lowercase_				:  Union[str, Any]				,			lowercase_				:  List[str]    ):
										if self.task in ["default", "seq2seq-lm"]:
																	lowercase_					:			Tuple										=       super()._flatten_past_key_values_(lowercase_				,			lowercase_				,			lowercase_				,			lowercase_    )
										else:
																	lowercase_					:			List[str]										=       super(lowercase_				,			self    )._flatten_past_key_values_(
																	    lowercase_				,			lowercase_				,			lowercase_				,			lowercase_    )






'''simple docstring'''




import sacrebleu as scb
from packaging import version
from sacrebleu import TER

import datasets


_lowercase						: List[str]						=						"\\n@inproceedings{snover-etal-2006-study,\n    title = \"A Study of Translation Edit Rate with Targeted Human Annotation\",\n    author = \"Snover, Matthew  and\n      Dorr, Bonnie  and\n      Schwartz, Rich  and\n      Micciulla, Linnea  and\n      Makhoul, John\",\n    booktitle = \"Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers\",\n    month = aug # \" 8-12\",\n    year = \"2006\",\n    address = \"Cambridge, Massachusetts, USA\",\n    publisher = \"Association for Machine Translation in the Americas\",\n    url = \"https://aclanthology.org/2006.amta-papers.25\",\n    pages = \"223--231\",\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"

_lowercase						: Tuple						=						"\\nTER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a\nhypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu\n(https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found\nhere: https://github.com/jhclark/tercom.\n\nThe implementation here is slightly different from sacrebleu in terms of the required input format. The length of\nthe references and hypotheses lists need to be the same, so you may need to transpose your references compared to\nsacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534\n\nSee the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information.\n"

_lowercase						: Optional[int]						=						"\nProduces TER scores alongside the number of edits and reference length.\n\nArgs:\n    predictions (list of str): The system stream (a sequence of segments).\n    references (list of list of str): A list of one or more reference streams (each a sequence of segments).\n    normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.\n    ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.\n    support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters,\n                                    as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana.\n                                    Only applies if `normalized = True`. Defaults to `False`.\n    case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`.\n\nReturns:\n    'score' (float): TER score (num_edits / sum_ref_lengths * 100)\n    'num_edits' (int): The cumulative number of edits\n    'ref_length' (float): The cumulative average reference length\n\nExamples:\n    Example 1:\n        >>> predictions = [\"does this sentence match??\",\n        ...                     \"what about this sentence?\",\n        ...                     \"What did the TER metric user say to the developer?\"]\n        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],\n        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"],\n        ...             [\"Your jokes are...\", \"...TERrible\"]]\n        >>> ter = datasets.load_metric(\"ter\")\n        >>> results = ter.compute(predictions=predictions,\n        ...                         references=references,\n        ...                         case_sensitive=True)\n        >>> print(results)\n        {'score': 150.0, 'num_edits': 15, 'ref_length': 10.0}\n\n    Example 2:\n        >>> predictions = [\"does this sentence match??\",\n        ...                     \"what about this sentence?\"]\n        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],\n        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]\n        >>> ter = datasets.load_metric(\"ter\")\n        >>> results = ter.compute(predictions=predictions,\n        ...                         references=references,\n        ...                         case_sensitive=True)\n        >>> print(results)\n        {'score': 62.5, 'num_edits': 5, 'ref_length': 8.0}\n\n    Example 3:\n        >>> predictions = [\"does this sentence match??\",\n        ...                     \"what about this sentence?\"]\n        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],\n        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]\n        >>> ter = datasets.load_metric(\"ter\")\n        >>> results = ter.compute(predictions=predictions,\n        ...                         references=references,\n        ...                         normalized=True,\n        ...                         case_sensitive=True)\n        >>> print(results)\n        {'score': 57.14285714285714, 'num_edits': 6, 'ref_length': 10.5}\n\n    Example 4:\n        >>> predictions = [\"does this sentence match??\",\n        ...                     \"what about this sentence?\"]\n        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],\n        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]\n        >>> ter = datasets.load_metric(\"ter\")\n        >>> results = ter.compute(predictions=predictions,\n        ...                         references=references,\n        ...                         ignore_punct=True,\n        ...                         case_sensitive=False)\n        >>> print(results)\n        {'score': 0.0, 'num_edits': 0, 'ref_length': 8.0}\n\n    Example 5:\n        >>> predictions = [\"does this sentence match??\",\n        ...                    \"what about this sentence?\",\n        ...                    \"What did the TER metric user say to the developer?\"]\n        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],\n        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"],\n        ...             [\"Your jokes are...\", \"...TERrible\"]]\n        >>> ter = datasets.load_metric(\"ter\")\n        >>> results = ter.compute(predictions=predictions,\n        ...                         references=references,\n        ...                         ignore_punct=True,\n        ...                         case_sensitive=False)\n        >>> print(results)\n        {'score': 100.0, 'num_edits': 10, 'ref_length': 10.0}\n"





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







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										if version.parse(scb.__version__    ) < version.parse("""1.4.12"""    ):
																	raise ImportWarning(
																	    """To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"""
																	    """You can install it with `pip install \"sacrebleu>=1.4.12\"`."""    )
										return datasets.MetricInfo(
										    description=_DESCRIPTION				,			citation=_CITATION				,			homepage="""http://www.cs.umd.edu/~snover/tercom/"""				,			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/mjpost/sacreBLEU#ter"""]				,			reference_urls=[
										        """https://github.com/jhclark/tercom""",
										    ]				,			)







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any				,			lowercase_				:  Any				,			lowercase_				:  Tuple				,			lowercase_				:  bool = False				,			lowercase_				:  bool = False				,			lowercase_				:  bool = False				,			lowercase_				:  bool = False				,			):
										lowercase_					:			int										=       len(references[0]    )
										if any(len(lowercase_    ) != references_per_prediction for refs in references    ):
																	raise ValueError("""Sacrebleu requires the same number of references for each prediction"""    )
										lowercase_					:			Optional[int]										=       [[refs[i] for refs in references] for i in range(lowercase_    )]

										lowercase_					:			List[str]										=       TER(
										    normalized=lowercase_				,			no_punct=lowercase_				,			asian_support=lowercase_				,			case_sensitive=lowercase_				,			)
										lowercase_					:			List[str]										=       sb_ter.corpus_score(lowercase_				,			lowercase_    )

										return {"score": output.score, "num_edits": output.num_edits, "ref_length": output.ref_length}





