





'''simple docstring'''






import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


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

snake_case_     =				"""\
METEOR, an automatic metric for machine translation evaluation
that is based on a generalized concept of unigram matching between the
machine-produced translation and human-produced reference translations.
Unigrams can be matched based on their surface forms, stemmed forms,
and meanings; furthermore, METEOR can be easily extended to include more
advanced matching strategies. Once all generalized unigram matches
between the two strings have been found, METEOR computes a score for
this matching using a combination of unigram-precision, unigram-recall, and
a measure of fragmentation that is designed to directly capture how
well-ordered the matched words in the machine translation are in relation
to the reference.

METEOR gets an R correlation value of 0.347 with human evaluation on the Arabic
data and 0.331 on the Chinese data. This is shown to be an improvement on
using simply unigram-precision, unigram-recall and their harmonic F1
combination.
"""

snake_case_     =				"""
Computes METEOR score of translated segments against one or more references.
Args:
    predictions: list of predictions to score. Each prediction
        should be a string with tokens separated by spaces.
    references: list of reference for each prediction. Each
        reference should be a string with tokens separated by spaces.
    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9
    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3
    gamma: Relative weight assigned to fragmentation penalty. default: 0.5
Returns:
    'meteor': meteor score.
Examples:

    >>> meteor = datasets.load_metric('meteor')
    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]
    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]
    >>> results = meteor.compute(predictions=predictions, references=references)
    >>> print(round(results[\"meteor\"], 4))
    0.6944
"""


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


   def 					snake_case				( self					):
       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 					snake_case				( self    ,   _UpperCAmelCase					):
       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 					snake_case				( self    ,   _UpperCAmelCase    ,   _UpperCAmelCase    ,   _UpperCAmelCase=0.9    ,   _UpperCAmelCase=3    ,   _UpperCAmelCase=0.5					):
       if NLTK_VERSION >= version.Version('''3.6.5'''					):
           A       :       str							=						[
               meteor_score.single_meteor_score(
                   word_tokenize(_UpperCAmelCase					)    ,   word_tokenize(_UpperCAmelCase					)    ,   alpha=_UpperCAmelCase    ,   beta=_UpperCAmelCase    ,   gamma=_UpperCAmelCase					)
               for ref, pred in zip(_UpperCAmelCase    ,   _UpperCAmelCase					)
           ]
       else:
           A       :       Tuple							=						[
               meteor_score.single_meteor_score(_UpperCAmelCase    ,   _UpperCAmelCase    ,   alpha=_UpperCAmelCase    ,   beta=_UpperCAmelCase    ,   gamma=_UpperCAmelCase					)
               for ref, pred in zip(_UpperCAmelCase    ,   _UpperCAmelCase					)
           ]

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







'''simple docstring'''






def 							_lowerCamelCase(  UpperCamelCase__    : Union[str, Any]    ,       UpperCamelCase__    : str		)		->  Optional[Any]:
    A       :       Tuple							=						0
    while b > 0:
        if b & 1:
            res += a

        a += a
        b >>= 1

    return res
def 							_lowerCamelCase(  UpperCamelCase__    : Any    ,       UpperCamelCase__    : Any    ,       UpperCamelCase__    : List[str]		)		->  Any:
    A       :       str							=						0
    while b > 0:
        if b & 1:
            A       :       List[Any]							=						((res % c) + (a % c)) % c

        a += a
        b >>= 1

    return res
