





import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


UpperCAmelCase						:   Optional[Any]			  =     version.parse(importlib_metadata.version('''nltk'''))
if NLTK_VERSION >= version.Version('''3.6.4'''):
				from nltk import word_tokenize


UpperCAmelCase						:   List[Any]			  =     '''\
@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},
}
'''

UpperCAmelCase						:   str			  =     '''\
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.
'''

UpperCAmelCase						:   Optional[Any]			  =     '''
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 						_A(					datasets.Metric   ):


				"""simple docstring"""


				def 					UpperCAmelCase_		(			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 					UpperCAmelCase_		(			self     ,					_A     ):
									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     ,					_A     ,					_A     ,					_A=0.9     ,					_A=3     ,					_A=0.5     ):
									if NLTK_VERSION >= version.Version('3.6.5'     ):
														__A	:						Tuple       =				[
														    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:
														__A	:						Dict       =				[
														    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     )}











import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
				from PIL import Image

				from transformers import OwlViTImageProcessor, OwlViTProcessor





@require_vision
class 						_A(					unittest.TestCase   ):


				"""simple docstring"""


				def 					UpperCAmelCase_		(			self     ):
									__A	:						List[Any]       =				tempfile.mkdtemp()

									# fmt: off
									__A	:						List[str]       =				['', 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
									# fmt: on
									__A	:						Union[str, Any]       =				dict(zip(_A     ,					range(len(_A     )     )     )     )
									__A	:						Optional[int]       =				['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', '']
									__A	:						int       =				{'unk_token': '<unk>'}

									__A	:						Optional[int]       =				os.path.join(self.tmpdirname     ,					VOCAB_FILES_NAMES['vocab_file']     )
									__A	:						int       =				os.path.join(self.tmpdirname     ,					VOCAB_FILES_NAMES['merges_file']     )
									with open(self.vocab_file     ,					'w'     ,					encoding='utf-8'     ) as fp:
														fp.write(json.dumps(_A     ) + '\n'     )
									with open(self.merges_file     ,					'w'     ,					encoding='utf-8'     ) as fp:
														fp.write('\n'.join(_A     )     )

									__A	:						List[Any]       =				{
									    'do_resize': True,
									    'size': 20,
									    'do_center_crop': True,
									    'crop_size': 18,
									    'do_normalize': True,
									    'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
									    'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
									}
									__A	:						Optional[int]       =				os.path.join(self.tmpdirname     ,					_A     )
									with open(self.image_processor_file     ,					'w'     ,					encoding='utf-8'     ) as fp:
														json.dump(_A     ,					_A     )



				def 					UpperCAmelCase_		(			self     ,					**_A     ):
									return CLIPTokenizer.from_pretrained(self.tmpdirname     ,					pad_token='!'     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ,					**_A     ):
									return CLIPTokenizerFast.from_pretrained(self.tmpdirname     ,					pad_token='!'     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ,					**_A     ):
									return OwlViTImageProcessor.from_pretrained(self.tmpdirname     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ):
									shutil.rmtree(self.tmpdirname     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						int       =				[np.random.randint(255     ,					size=(3, 30, 400)     ,					dtype=np.uinta     )]

									__A	:						Optional[int]       =				[Image.fromarray(np.moveaxis(_A     ,					0     ,					-1     )     ) for x in image_inputs]

									return image_inputs



				def 					UpperCAmelCase_		(			self     ):
									__A	:						List[Any]       =				self.get_tokenizer()
									__A	:						str       =				self.get_rust_tokenizer()
									__A	:						List[str]       =				self.get_image_processor()

									__A	:						Optional[int]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )
									processor_slow.save_pretrained(self.tmpdirname     )
									__A	:						int       =				OwlViTProcessor.from_pretrained(self.tmpdirname     ,					use_fast=_A     )

									__A	:						Optional[Any]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )
									processor_fast.save_pretrained(self.tmpdirname     )
									__A	:						Optional[Any]       =				OwlViTProcessor.from_pretrained(self.tmpdirname     )

									self.assertEqual(processor_slow.tokenizer.get_vocab()     ,					tokenizer_slow.get_vocab()     )
									self.assertEqual(processor_fast.tokenizer.get_vocab()     ,					tokenizer_fast.get_vocab()     )
									self.assertEqual(tokenizer_slow.get_vocab()     ,					tokenizer_fast.get_vocab()     )
									self.assertIsInstance(processor_slow.tokenizer     ,					_A     )
									self.assertIsInstance(processor_fast.tokenizer     ,					_A     )

									self.assertEqual(processor_slow.image_processor.to_json_string()     ,					image_processor.to_json_string()     )
									self.assertEqual(processor_fast.image_processor.to_json_string()     ,					image_processor.to_json_string()     )
									self.assertIsInstance(processor_slow.image_processor     ,					_A     )
									self.assertIsInstance(processor_fast.image_processor     ,					_A     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						List[str]       =				OwlViTProcessor(tokenizer=self.get_tokenizer()     ,					image_processor=self.get_image_processor()     )
									processor.save_pretrained(self.tmpdirname     )

									__A	:						Optional[int]       =				self.get_tokenizer(bos_token='(BOS)'     ,					eos_token='(EOS)'     )
									__A	:						Optional[int]       =				self.get_image_processor(do_normalize=_A     )

									__A	:						Any       =				OwlViTProcessor.from_pretrained(
									    self.tmpdirname     ,					bos_token='(BOS)'     ,					eos_token='(EOS)'     ,					do_normalize=_A     )

									self.assertEqual(processor.tokenizer.get_vocab()     ,					tokenizer_add_kwargs.get_vocab()     )
									self.assertIsInstance(processor.tokenizer     ,					_A     )

									self.assertEqual(processor.image_processor.to_json_string()     ,					image_processor_add_kwargs.to_json_string()     )
									self.assertIsInstance(processor.image_processor     ,					_A     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						Optional[Any]       =				self.get_image_processor()
									__A	:						Optional[Any]       =				self.get_tokenizer()

									__A	:						Union[str, Any]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						Union[str, Any]       =				self.prepare_image_inputs()

									__A	:						int       =				image_processor(_A     ,					return_tensors='np'     )
									__A	:						str       =				processor(images=_A     ,					return_tensors='np'     )

									for key in input_image_proc.keys():
														self.assertAlmostEqual(input_image_proc[key].sum()     ,					input_processor[key].sum()     ,					delta=1e-2     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						str       =				self.get_image_processor()
									__A	:						str       =				self.get_tokenizer()

									__A	:						Tuple       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						str       =				'lower newer'

									__A	:						str       =				processor(text=_A     ,					return_tensors='np'     )

									__A	:						List[str]       =				tokenizer(_A     ,					return_tensors='np'     )

									for key in encoded_tok.keys():
														self.assertListEqual(encoded_tok[key][0].tolist()     ,					encoded_processor[key][0].tolist()     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						int       =				self.get_image_processor()
									__A	:						Optional[int]       =				self.get_tokenizer()

									__A	:						List[str]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						Any       =				'lower newer'
									__A	:						Optional[Any]       =				self.prepare_image_inputs()

									__A	:						List[Any]       =				processor(text=_A     ,					images=_A     )

									self.assertListEqual(list(inputs.keys()     )     ,					['input_ids', 'attention_mask', 'pixel_values']     )

									# test if it raises when no input is passed
									with pytest.raises(_A     ):
														processor()



				def 					UpperCAmelCase_		(			self     ):
									__A	:						Any       =				'google/owlvit-base-patch32'
									__A	:						int       =				OwlViTProcessor.from_pretrained(_A     )

									__A	:						Dict       =				['cat', 'nasa badge']
									__A	:						Optional[Any]       =				processor(text=_A     )

									__A	:						Optional[int]       =				16
									self.assertListEqual(list(inputs.keys()     )     ,					['input_ids', 'attention_mask']     )
									self.assertEqual(inputs['input_ids'].shape     ,					(2, seq_length)     )

									# test if it raises when no input is passed
									with pytest.raises(_A     ):
														processor()



				def 					UpperCAmelCase_		(			self     ):
									__A	:						Tuple       =				'google/owlvit-base-patch32'
									__A	:						Any       =				OwlViTProcessor.from_pretrained(_A     )

									__A	:						Dict       =				[['cat', 'nasa badge'], ['person']]
									__A	:						Dict       =				processor(text=_A     )

									__A	:						Optional[int]       =				16
									__A	:						Any       =				len(_A     )
									__A	:						Union[str, Any]       =				max([len(_A     ) for texts in input_texts]     )

									self.assertListEqual(list(inputs.keys()     )     ,					['input_ids', 'attention_mask']     )
									self.assertEqual(inputs['input_ids'].shape     ,					(batch_size * num_max_text_queries, seq_length)     )

									# test if it raises when no input is passed
									with pytest.raises(_A     ):
														processor()



				def 					UpperCAmelCase_		(			self     ):
									__A	:						List[Any]       =				'google/owlvit-base-patch32'
									__A	:						str       =				OwlViTProcessor.from_pretrained(_A     )

									__A	:						Union[str, Any]       =				['cat', 'nasa badge']
									__A	:						Tuple       =				processor(text=_A     )

									__A	:						str       =				16
									__A	:						int       =				inputs['input_ids']
									__A	:						List[Any]       =				[
									    [49406, 2368, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
									    [49406, 6841, 11301, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
									]

									self.assertListEqual(list(inputs.keys()     )     ,					['input_ids', 'attention_mask']     )
									self.assertEqual(inputs['input_ids'].shape     ,					(2, seq_length)     )
									self.assertListEqual(list(input_ids[0]     )     ,					predicted_ids[0]     )
									self.assertListEqual(list(input_ids[1]     )     ,					predicted_ids[1]     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						Optional[Any]       =				self.get_image_processor()
									__A	:						List[str]       =				self.get_tokenizer()

									__A	:						Optional[Any]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						Optional[int]       =				self.prepare_image_inputs()
									__A	:						Optional[int]       =				self.prepare_image_inputs()

									__A	:						Optional[int]       =				processor(images=_A     ,					query_images=_A     )

									self.assertListEqual(list(inputs.keys()     )     ,					['query_pixel_values', 'pixel_values']     )

									# test if it raises when no input is passed
									with pytest.raises(_A     ):
														processor()





				def 					UpperCAmelCase_		(			self     ):
									__A	:						Optional[Any]       =				self.get_image_processor()
									__A	:						Union[str, Any]       =				self.get_tokenizer()

									__A	:						str       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						Optional[Any]       =				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

									__A	:						Any       =				processor.batch_decode(_A     )
									__A	:						Tuple       =				tokenizer.batch_decode(_A     )

									self.assertListEqual(_A     ,					_A     )




