

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
      import PIL


lowerCAmelCase__       = logging.get_logger(__name__)






class 						__magic_name__    (       _snake_case    ):
 UpperCAmelCase							    =						["""pixel_values"""]


 def __init__(						self		: Dict			,						lowerCAmelCase__		: bool = True			,						lowerCAmelCase__		: Dict[str, int] = None			,						lowerCAmelCase__		: PILImageResampling = PIL.Image.BICUBIC			,						lowerCAmelCase__		: bool = True			,						lowerCAmelCase__		: Dict[str, int] = None			,						lowerCAmelCase__		: Union[int, float] = 1 / 2_5_5			,						lowerCAmelCase__		: bool = True			,						lowerCAmelCase__		: bool = True			,						lowerCAmelCase__		: Optional[Union[float, List[float]]] = None			,						lowerCAmelCase__		: Optional[Union[float, List[float]]] = None			,						**lowerCAmelCase__		: List[str]			,						)    ->      None:
   super().__init__(**lowerCAmelCase__    )
   UpperCAmelCase					      =  size if size is not None else {"height": 2_5_6, "width": 2_5_6}
   UpperCAmelCase					      =  get_size_dict(lowerCAmelCase__    )
   UpperCAmelCase					      =  crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
   UpperCAmelCase					      =  get_size_dict(lowerCAmelCase__			,						param_name="crop_size"    )

   UpperCAmelCase					      =  do_resize
   UpperCAmelCase					      =  size
   UpperCAmelCase					      =  resample
   UpperCAmelCase					      =  do_center_crop
   UpperCAmelCase					      =  crop_size
   UpperCAmelCase					      =  do_rescale
   UpperCAmelCase					      =  rescale_factor
   UpperCAmelCase					      =  do_normalize
   UpperCAmelCase					      =  image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
   UpperCAmelCase					      =  image_std if image_std is not None else IMAGENET_STANDARD_STD


 def _UpperCamelCase	(						self		: Dict			,						lowerCAmelCase__		: np.ndarray			,						lowerCAmelCase__		: Dict[str, int]			,						lowerCAmelCase__		: PILImageResampling = PIL.Image.BICUBIC			,						lowerCAmelCase__		: Optional[Union[str, ChannelDimension]] = None			,						**lowerCAmelCase__		: Optional[int]			,						)    ->      np.ndarray:
   UpperCAmelCase					      =  get_size_dict(lowerCAmelCase__    )
   if "height" not in size or "width" not in size:
     raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"    )
   return resize(
       lowerCAmelCase__			,						size=(size["height"], size["width"])			,						resample=lowerCAmelCase__			,						data_format=lowerCAmelCase__			,						**lowerCAmelCase__    )


 def _UpperCamelCase	(						self		: Any			,						lowerCAmelCase__		: np.ndarray			,						lowerCAmelCase__		: Dict[str, int]			,						lowerCAmelCase__		: Optional[Union[str, ChannelDimension]] = None			,						**lowerCAmelCase__		: List[str]			,						)    ->      np.ndarray:
   UpperCAmelCase					      =  get_size_dict(lowerCAmelCase__    )
   if "height" not in size or "width" not in size:
     raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"    )
   return center_crop(lowerCAmelCase__			,						size=(size["height"], size["width"])			,						data_format=lowerCAmelCase__			,						**lowerCAmelCase__    )


 def _UpperCamelCase	(						self		: int			,						lowerCAmelCase__		: np.ndarray			,						lowerCAmelCase__		: Union[int, float]			,						lowerCAmelCase__		: Optional[Union[str, ChannelDimension]] = None			,						**lowerCAmelCase__		: Tuple			,						)    ->      List[str]:
   return rescale(lowerCAmelCase__			,						scale=lowerCAmelCase__			,						data_format=lowerCAmelCase__			,						**lowerCAmelCase__    )


 def _UpperCamelCase	(						self		: List[str]			,						lowerCAmelCase__		: np.ndarray			,						lowerCAmelCase__		: Union[float, List[float]]			,						lowerCAmelCase__		: Union[float, List[float]]			,						lowerCAmelCase__		: Optional[Union[str, ChannelDimension]] = None			,						**lowerCAmelCase__		: Union[str, Any]			,						)    ->      np.ndarray:
   return normalize(lowerCAmelCase__			,						mean=lowerCAmelCase__			,						std=lowerCAmelCase__			,						data_format=lowerCAmelCase__			,						**lowerCAmelCase__    )


 def _UpperCamelCase	(						self		: Optional[Any]			,						lowerCAmelCase__		: ImageInput			,						lowerCAmelCase__		: bool = None			,						lowerCAmelCase__		: Dict[str, int] = None			,						lowerCAmelCase__		: Tuple=None			,						lowerCAmelCase__		: bool = None			,						lowerCAmelCase__		: Dict[str, int] = None			,						lowerCAmelCase__		: bool = None			,						lowerCAmelCase__		: float = None			,						lowerCAmelCase__		: bool = None			,						lowerCAmelCase__		: Optional[Union[float, List[float]]] = None			,						lowerCAmelCase__		: Optional[Union[float, List[float]]] = None			,						lowerCAmelCase__		: Optional[Union[str, TensorType]] = None			,						lowerCAmelCase__		: ChannelDimension = ChannelDimension.FIRST			,						**lowerCAmelCase__		: Optional[Any]			,						)    ->      PIL.Image.Image:
   UpperCAmelCase					      =  do_resize if do_resize is not None else self.do_resize
   UpperCAmelCase					      =  resample if resample is not None else self.resample
   UpperCAmelCase					      =  do_center_crop if do_center_crop is not None else self.do_center_crop
   UpperCAmelCase					      =  do_rescale if do_rescale is not None else self.do_rescale
   UpperCAmelCase					      =  rescale_factor if rescale_factor is not None else self.rescale_factor
   UpperCAmelCase					      =  do_normalize if do_normalize is not None else self.do_normalize
   UpperCAmelCase					      =  image_mean if image_mean is not None else self.image_mean
   UpperCAmelCase					      =  image_std if image_std is not None else self.image_std

   UpperCAmelCase					      =  size if size is not None else self.size
   UpperCAmelCase					      =  get_size_dict(lowerCAmelCase__    )
   UpperCAmelCase					      =  crop_size if crop_size is not None else self.crop_size
   UpperCAmelCase					      =  get_size_dict(lowerCAmelCase__			,						param_name="crop_size"    )

   UpperCAmelCase					      =  make_list_of_images(lowerCAmelCase__    )

   if not valid_images(lowerCAmelCase__    ):
     raise ValueError(
         "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
         "torch.Tensor, tf.Tensor or jax.ndarray."    )

   if do_resize and size is None or resample is None:
     raise ValueError("Size and resample must be specified if do_resize is True."    )

   if do_center_crop and crop_size is None:
     raise ValueError("Crop size must be specified if do_center_crop is True."    )

   if do_rescale and rescale_factor is None:
     raise ValueError("Rescale factor must be specified if do_rescale is True."    )

   if do_normalize and (image_mean is None or image_std is None):
     raise ValueError("Image mean and std must be specified if do_normalize is True."    )

   # All transformations expect numpy arrays.
   UpperCAmelCase					      =  [to_numpy_array(lowerCAmelCase__    ) for image in images]

   if do_resize:
     UpperCAmelCase					      =  [self.resize(image=lowerCAmelCase__			,						size=lowerCAmelCase__			,						resample=lowerCAmelCase__    ) for image in images]

   if do_center_crop:
     UpperCAmelCase					      =  [self.center_crop(image=lowerCAmelCase__			,						size=lowerCAmelCase__    ) for image in images]

   if do_rescale:
     UpperCAmelCase					      =  [self.rescale(image=lowerCAmelCase__			,						scale=lowerCAmelCase__    ) for image in images]

   if do_normalize:
     UpperCAmelCase					      =  [self.normalize(image=lowerCAmelCase__			,						mean=lowerCAmelCase__			,						std=lowerCAmelCase__    ) for image in images]

   UpperCAmelCase					      =  [to_channel_dimension_format(lowerCAmelCase__			,						lowerCAmelCase__    ) for image in images]

   UpperCAmelCase					      =  {"pixel_values": images}
   return BatchFeature(data=lowerCAmelCase__			,						tensor_type=lowerCAmelCase__    )






import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


lowerCAmelCase__       = "\\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"

lowerCAmelCase__       = "\\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"

lowerCAmelCase__       = "\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 						__magic_name__    (       datasets.Metric    ):


 def _UpperCamelCase	(						self		: int    )    ->      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 _UpperCamelCase	(						self		: Dict			,						lowerCAmelCase__		: List[Any]    )    ->      Dict:
   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 _UpperCamelCase	(						self		: Union[str, Any]			,						lowerCAmelCase__		: int			,						lowerCAmelCase__		: Dict			,						lowerCAmelCase__		: Any=0.9			,						lowerCAmelCase__		: Tuple=3			,						lowerCAmelCase__		: Optional[int]=0.5    )    ->      Any:
   if NLTK_VERSION >= version.Version("3.6.5"    ):
     UpperCAmelCase					      =  [
         meteor_score.single_meteor_score(
             word_tokenize(lowerCAmelCase__    )			,						word_tokenize(lowerCAmelCase__    )			,						alpha=lowerCAmelCase__			,						beta=lowerCAmelCase__			,						gamma=lowerCAmelCase__    )
         for ref, pred in zip(lowerCAmelCase__			,						lowerCAmelCase__    )
     ]
   else:
     UpperCAmelCase					      =  [
         meteor_score.single_meteor_score(lowerCAmelCase__			,						lowerCAmelCase__			,						alpha=lowerCAmelCase__			,						beta=lowerCAmelCase__			,						gamma=lowerCAmelCase__    )
         for ref, pred in zip(lowerCAmelCase__			,						lowerCAmelCase__    )
     ]

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



