
"""simple docstring"""

import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


SCREAMING_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},
}
'''

SCREAMING_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.
'''

SCREAMING_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   _UpperCAmelCase				(		datasets.Metric				):




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

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





"""simple docstring"""

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_				):
      __SCREAMING_SNAKE_CASE :				List[Any]				   =						["image_processor", "tokenizer"]
      __SCREAMING_SNAKE_CASE :				Dict				   =						"AutoImageProcessor"
      __SCREAMING_SNAKE_CASE :				Optional[int]				   =						"AutoTokenizer"




      def __init__(				self ,							lowercase_ ,							lowercase_				)    ->       List[str]:
          super().__init__(lowercase_ ,							lowercase_				)
          UpperCAmelCase          =       self.image_processor




      def __call__(				self ,							lowercase_=None ,							lowercase_=None ,							lowercase_=None ,							**lowercase_				)    ->       Any:

          if text is None and images is None:
              raise ValueError('You have to specify either text or images. Both cannot be none.'				)

          if text is not None:
              UpperCAmelCase          =       self.tokenizer(lowercase_ ,							return_tensors=lowercase_ ,							**lowercase_				)

          if images is not None:
              UpperCAmelCase          =       self.image_processor(lowercase_ ,							return_tensors=lowercase_ ,							**lowercase_				)

          if text is not None and images is not None:
              UpperCAmelCase          =       image_features.pixel_values
              return encoding
          elif text is not None:
              return encoding
          else:
              return BatchEncoding(data=dict(**lowercase_				) ,							tensor_type=lowercase_				)




      def      a_   (				self ,							*lowercase_ ,							**lowercase_				)    ->       Optional[Any]:
          return self.tokenizer.batch_decode(*lowercase_ ,							**lowercase_				)




      def      a_   (				self ,							*lowercase_ ,							**lowercase_				)    ->       Optional[int]:
          return self.tokenizer.decode(*lowercase_ ,							**lowercase_				)




      @property
      def      a_   (				self				)    ->       Optional[int]:
          return ["input_ids", "attention_mask", "pixel_values"]



