
'''simple docstring'''







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,
    get_resize_output_image_size,
    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, logging


lowercase					:							Dict   =      logging.get_logger(__name__)


class 		__UpperCAmelCase   (      _lowerCamelCase		):
							__lowercase   	= ["""pixel_values"""]


							def __init__( self					,     lowerCAmelCase_ = True					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = PILImageResampling.BILINEAR					,     lowerCAmelCase_ = True					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = True					,     lowerCAmelCase_ = 1 / 2_55					,     lowerCAmelCase_ = True					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								super().__init__(**lowerCAmelCase_						)
								_snake_case     		=	size if size is not None else {'shortest_edge': 2_56}
								_snake_case     		=	get_size_dict(lowerCAmelCase_					,     default_to_square=lowerCAmelCase_						)
								_snake_case     		=	crop_size if crop_size is not None else {'height': 2_24, 'width': 2_24}
								_snake_case     		=	get_size_dict(lowerCAmelCase_						)
								_snake_case     		=	do_resize
								_snake_case     		=	size
								_snake_case     		=	resample
								_snake_case     		=	do_center_crop
								_snake_case     		=	crop_size
								_snake_case     		=	do_rescale
								_snake_case     		=	rescale_factor
								_snake_case     		=	do_normalize
								_snake_case     		=	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
								_snake_case     		=	image_std if image_std is not None else IMAGENET_STANDARD_STD


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = PILImageResampling.BICUBIC					,     lowerCAmelCase_ = None					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								_snake_case     		=	get_size_dict(lowerCAmelCase_					,     default_to_square=lowerCAmelCase_						)
								if "shortest_edge" not in size:
									raise ValueError(F'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'						)
								_snake_case     		=	get_resize_output_image_size(lowerCAmelCase_					,     size=size['shortest_edge']					,     default_to_square=lowerCAmelCase_						)
								return resize(lowerCAmelCase_					,     size=lowerCAmelCase_					,     resample=lowerCAmelCase_					,     data_format=lowerCAmelCase_					,     **lowerCAmelCase_						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = None					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								_snake_case     		=	get_size_dict(lowerCAmelCase_						)
								return center_crop(lowerCAmelCase_					,     size=(size['height'], size['width'])					,     data_format=lowerCAmelCase_					,     **lowerCAmelCase_						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = None					,     **lowerCAmelCase_						):





								"""simple docstring"""






								return rescale(lowerCAmelCase_					,     scale=lowerCAmelCase_					,     data_format=lowerCAmelCase_					,     **lowerCAmelCase_						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = None					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								return normalize(lowerCAmelCase_					,     mean=lowerCAmelCase_					,     std=lowerCAmelCase_					,     data_format=lowerCAmelCase_					,     **lowerCAmelCase_						)




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = ChannelDimension.FIRST					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								_snake_case     		=	do_resize if do_resize is not None else self.do_resize
								_snake_case     		=	size if size is not None else self.size
								_snake_case     		=	get_size_dict(lowerCAmelCase_					,     default_to_square=lowerCAmelCase_						)
								_snake_case     		=	resample if resample is not None else self.resample
								_snake_case     		=	do_center_crop if do_center_crop is not None else self.do_center_crop
								_snake_case     		=	crop_size if crop_size is not None else self.crop_size
								_snake_case     		=	get_size_dict(lowerCAmelCase_						)
								_snake_case     		=	do_rescale if do_rescale is not None else self.do_rescale
								_snake_case     		=	rescale_factor if rescale_factor is not None else self.rescale_factor
								_snake_case     		=	do_normalize if do_normalize is not None else self.do_normalize
								_snake_case     		=	image_mean if image_mean is not None else self.image_mean
								_snake_case     		=	image_std if image_std is not None else self.image_std

								_snake_case     		=	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:
									raise ValueError('Size 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.
								_snake_case     		=	[to_numpy_array(lowerCAmelCase_						) for image in images]

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

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

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

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

								_snake_case     		=	[to_channel_dimension_format(lowerCAmelCase_					,     lowerCAmelCase_						) for image in images]

								_snake_case     		=	{'pixel_values': images}
								return BatchFeature(data=lowerCAmelCase_					,     tensor_type=lowerCAmelCase_						)



'''simple docstring'''







import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


lowercase					:							int   =      "\\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					:							Any   =      "\\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					:							Optional[Any]   =      "\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 		__UpperCAmelCase   (      datasets.Metric		):


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								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 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								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 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_=0.9					,     lowerCAmelCase_=3					,     lowerCAmelCase_=0.5						):





								"""simple docstring"""






								if NLTK_VERSION >= version.Version('3.6.5'						):
									_snake_case     		=	[
									    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:
									_snake_case     		=	[
									    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_						)}

