



import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


lowercase_								=     version.parse(importlib_metadata.version("""nltk"""))
if NLTK_VERSION >= version.Version("""3.6.4"""):
	from nltk import word_tokenize


lowercase_								=     "\\n@inproceedings{banarjee2005,\n  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n  author    = {Banerjee, Satanjeev  and Lavie, Alon},\n  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n  month     = jun,\n  year      = {2005},\n  address   = {Ann Arbor, Michigan},\n  publisher = {Association for Computational Linguistics},\n  url       = {https://www.aclweb.org/anthology/W05-0909},\n  pages     = {65--72},\n}\n"

lowercase_								=     "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n"

lowercase_								=     "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    'meteor': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric('meteor')\n    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results[\"meteor\"], 4))\n    0.6944\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,	_KWARGS_DESCRIPTION)
class 				_snake_case			(					datasets.Metric):




				def 							A__      (						self					:						Tuple						):
							return datasets.MetricInfo(
							    description=_DESCRIPTION,					citation=_CITATION,					inputs_description=_KWARGS_DESCRIPTION,					features=datasets.Features(
							        {
							            "predictions": datasets.Value("string",					id="sequence"						),
							            "references": datasets.Value("string",					id="sequence"						),
							        }						),					codebase_urls=["https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py"],					reference_urls=[
							        "https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score",
							        "https://en.wikipedia.org/wiki/METEOR",
							    ],					)




				def 							A__      (						self					:						Any,					__lowercase					:						List[Any]						):
							import nltk

							nltk.download("wordnet"						)
							if NLTK_VERSION >= version.Version("3.6.5"						):
										nltk.download("punkt"						)
							if NLTK_VERSION >= version.Version("3.6.6"						):
										nltk.download("omw-1.4"						)




				def 							A__      (						self					:						Any,					__lowercase					:						int,					__lowercase					:						List[str],					__lowercase					:						Union[str, Any]=0.9,					__lowercase					:						Any=3,					__lowercase					:						Dict=0.5						):


							if NLTK_VERSION >= version.Version("3.6.5"						):
										lowercase__					  =				[
										    meteor_score.single_meteor_score(
										        word_tokenize(_a						),					word_tokenize(_a						),					alpha=_a,					beta=_a,					gamma=_a						)
										    for ref, pred in zip(_a,					_a						)
										]
							else:
										lowercase__					  =				[
										    meteor_score.single_meteor_score(_a,					_a,					alpha=_a,					beta=_a,					gamma=_a						)
										    for ref, pred in zip(_a,					_a						)
										]

							return {"meteor": np.mean(_a						)}









from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments



def __lowerCAmelCase (     ):
			lowercase__					  =				HfArgumentParser(SCREAMING_SNAKE_CASE_  )
			lowercase__					  =				parser.parse_args_into_dataclasses()[0]
			lowercase__					  =				TensorFlowBenchmark(args=SCREAMING_SNAKE_CASE_  )
			try:
						lowercase__					  =				parser.parse_args_into_dataclasses()[0]
			except ValueError as e:
						lowercase__					  =				"Arg --no_{0} is no longer used, please use --no-{0} instead."
						lowercase__					  =				" ".join(str(SCREAMING_SNAKE_CASE_  ).split(" "  )[:-1]  )
						lowercase__					  =				""
						lowercase__					  =				eval(str(SCREAMING_SNAKE_CASE_  ).split(" "  )[-1]  )
						lowercase__					  =				[]
						for arg in depreciated_args:
									# arg[2:] removes '--'
									if arg[2:] in TensorFlowBenchmark.deprecated_args:
												# arg[5:] removes '--no_'
												full_error_msg += arg_error_msg.format(arg[5:]  )
									else:
												wrong_args.append(SCREAMING_SNAKE_CASE_  )
						if len(SCREAMING_SNAKE_CASE_  ) > 0:
									lowercase__					  =				full_error_msg + begin_error_msg + str(SCREAMING_SNAKE_CASE_  )
						raise ValueError(SCREAMING_SNAKE_CASE_  )
			benchmark.run()


if __name__ == "__main__":
							main()




