from typing import Dict, List

from nltk.translate import gleu_score

import datasets
from datasets import MetricInfo


_lowerCamelCase   :				int     			=						'''\
@misc{wu2016googles,
      title={Google\'s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},
      author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey
              and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin
              Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto
              Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and
              Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes
              and Jeffrey Dean},
      year={2016},
      eprint={1609.08144},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
'''

_lowerCamelCase   :				List[Any]     			=						'''\
The BLEU score has some undesirable properties when used for single
sentences, as it was designed to be a corpus measure. We therefore
use a slightly different score for our RL experiments which we call
the \'GLEU score\'. For the GLEU score, we record all sub-sequences of
1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then
compute a recall, which is the ratio of the number of matching n-grams
to the number of total n-grams in the target (ground truth) sequence,
and a precision, which is the ratio of the number of matching n-grams
to the number of total n-grams in the generated output sequence. Then
GLEU score is simply the minimum of recall and precision. This GLEU
score\'s range is always between 0 (no matches) and 1 (all match) and
it is symmetrical when switching output and target. According to
our experiments, GLEU score correlates quite well with the BLEU
metric on a corpus level but does not have its drawbacks for our per
sentence reward objective.
'''

_lowerCamelCase   :				Optional[int]     			=						'''\
Computes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.
Instead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching
tokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.

Args:
    predictions (list of str): list of translations to score.
        Each translation should be tokenized into a list of tokens.
    references (list of list of str): list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.
    max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.

Returns:
    \'google_bleu\': google_bleu score

Examples:
    Example 1:
        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',
        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',
        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']
        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',
        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',
        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']

        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',
        ...         \'interested\', \'in\', \'world\', \'history\']
        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',
        ...          \'because\', \'he\', \'read\', \'the\', \'book\']

        >>> list_of_references = [[ref1a], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric("google_bleu")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)
        >>> print(round(results["google_bleu"], 2))
        0.44

    Example 2:
        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',
        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',
        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']
        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',
        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',
        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']
        >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',
        ...          \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',
        ...          \'heed\', \'the\', \'cat\', \'commands\']
        >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',
        ...          \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',
        ...          \'of\', \'the\', \'cat\']

        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',
        ...         \'interested\', \'in\', \'world\', \'history\']
        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',
        ...          \'because\', \'he\', \'read\', \'the\', \'book\']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric("google_bleu")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)
        >>> print(round(results["google_bleu"], 2))
        0.61

    Example 3:
        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',
        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',
        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']
        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',
        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',
        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']
        >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',
        ...          \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',
        ...          \'heed\', \'the\', \'cat\', \'commands\']
        >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',
        ...          \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',
        ...          \'of\', \'the\', \'cat\']

        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',
        ...         \'interested\', \'in\', \'world\', \'history\']
        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',
        ...          \'because\', \'he\', \'read\', \'the\', \'book\']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric("google_bleu")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)
        >>> print(round(results["google_bleu"], 2))
        0.53

    Example 4:
        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',
        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',
        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']
        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',
        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',
        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']
        >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',
        ...          \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',
        ...          \'heed\', \'the\', \'cat\', \'commands\']
        >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',
        ...          \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',
        ...          \'of\', \'the\', \'cat\']

        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',
        ...         \'interested\', \'in\', \'world\', \'history\']
        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',
        ...          \'because\', \'he\', \'read\', \'the\', \'book\']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric("google_bleu")
        >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)
        >>> print(round(results["google_bleu"], 2))
        0.4
'''


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




							def 		__snake_case(  self				:   Tuple )   ->			MetricInfo:



												'''simple docstring'''

												return datasets.MetricInfo(
												    description=_DESCRIPTION		,							citation=_CITATION		,							inputs_description=_KWARGS_DESCRIPTION		,							features=datasets.Features(
												        {
												            "predictions": datasets.Sequence(datasets.Value("string"		,							id="token" )		,							id="sequence" ),
												            "references": datasets.Sequence(
												                datasets.Sequence(datasets.Value("string"		,							id="token" )		,							id="sequence" )		,							id="references" ),
												        } )		,							)





							def 		__snake_case(  self				:   Optional[int]		,							_UpperCamelCase				:   List[List[List[str]]]		,							_UpperCamelCase				:   List[List[str]]		,							_UpperCamelCase				:   int = 1		,							_UpperCamelCase				:   int = 4		,							)   ->			Dict[str, float]:



												'''simple docstring'''

												return {
												    "google_bleu": gleu_score.corpus_gleu(
												        list_of_references=_UpperCamelCase		,							hypotheses=_UpperCamelCase		,							min_len=_UpperCamelCase		,							max_len=_UpperCamelCase )
												}





import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import MobileNetVaForImageClassification, MobileNetVaModel
							from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import MobileNetVaImageProcessor


class   lowercase      (       a       ):




							def 		__snake_case(  self				:   Optional[int] )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.config_class(**self.inputs_dict )
												self.parent.assertTrue(hasattr(_UpperCamelCase		,							"tf_padding" ) )
												self.parent.assertTrue(hasattr(_UpperCamelCase		,							"depth_multiplier" ) )



class   lowercase      :




							def __init__(  self				:   Tuple		,							_UpperCamelCase				:   Optional[Any]		,							_UpperCamelCase				:   Any=13		,							_UpperCamelCase				:   Any=3		,							_UpperCamelCase				:   Union[str, Any]=32		,							_UpperCamelCase				:   Optional[Any]=0.2_5		,							_UpperCamelCase				:   int=8		,							_UpperCamelCase				:   str=True		,							_UpperCamelCase				:   Any=1_024		,							_UpperCamelCase				:   Tuple=32		,							_UpperCamelCase				:   List[str]="relu6"		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   List[str]=0.0_2		,							_UpperCamelCase				:   int=True		,							_UpperCamelCase				:   int=True		,							_UpperCamelCase				:   Optional[Any]=10		,							_UpperCamelCase				:   List[str]=None		,							)   ->			Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    parent
												SCREAMING_SNAKE_CASE           =    batch_size
												SCREAMING_SNAKE_CASE           =    num_channels
												SCREAMING_SNAKE_CASE           =    image_size
												SCREAMING_SNAKE_CASE           =    depth_multiplier
												SCREAMING_SNAKE_CASE           =    min_depth
												SCREAMING_SNAKE_CASE           =    tf_padding
												SCREAMING_SNAKE_CASE           =    int(last_hidden_size * depth_multiplier )
												SCREAMING_SNAKE_CASE           =    output_stride
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    classifier_dropout_prob
												SCREAMING_SNAKE_CASE           =    use_labels
												SCREAMING_SNAKE_CASE           =    is_training
												SCREAMING_SNAKE_CASE           =    num_labels
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    scope




							def 		__snake_case(  self				:   Dict )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

												SCREAMING_SNAKE_CASE           =    None
												SCREAMING_SNAKE_CASE           =    None
												if self.use_labels:
																	SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size]		,							self.num_labels )
																	SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size, self.image_size, self.image_size]		,							self.num_labels )

												SCREAMING_SNAKE_CASE           =    self.get_config()

												return config, pixel_values, labels, pixel_labels




							def 		__snake_case(  self				:   Optional[Any] )   ->			str:



												'''simple docstring'''

												return MobileNetVaConfig(
												    num_channels=self.num_channels		,							image_size=self.image_size		,							depth_multiplier=self.depth_multiplier		,							min_depth=self.min_depth		,							tf_padding=self.tf_padding		,							hidden_act=self.hidden_act		,							classifier_dropout_prob=self.classifier_dropout_prob		,							initializer_range=self.initializer_range		,							)




							def 		__snake_case(  self				:   int		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   Any		,							_UpperCamelCase				:   Union[str, Any]		,							_UpperCamelCase				:   int )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    MobileNetVaModel(config=_UpperCamelCase )
												model.to(_UpperCamelCase )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase )
												self.parent.assertEqual(
												    result.last_hidden_state.shape		,							(
												        self.batch_size,
												        self.last_hidden_size,
												        self.image_size // self.output_stride,
												        self.image_size // self.output_stride,
												    )		,							)




							def 		__snake_case(  self				:   Dict		,							_UpperCamelCase				:   Tuple		,							_UpperCamelCase				:   Any		,							_UpperCamelCase				:   str		,							_UpperCamelCase				:   List[Any] )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.num_labels
												SCREAMING_SNAKE_CASE           =    MobileNetVaForImageClassification(_UpperCamelCase )
												model.to(_UpperCamelCase )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase		,							labels=_UpperCamelCase )
												self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.num_labels) )





							def 		__snake_case(  self				:   Optional[Any] )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    config_and_inputs
												SCREAMING_SNAKE_CASE           =    {"pixel_values": pixel_values}
												return config, inputs_dict



@require_torch
class   lowercase      (       a			,    a			,    unittest.TestCase       ):
							lowercase__  :    Dict									=							(MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
							lowercase__  :    Tuple									=							(
							    {"""feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							lowercase__  :    Union[str, Any]									=							False
							lowercase__  :    Union[str, Any]									=							False
							lowercase__  :    Tuple									=							False
							lowercase__  :    List[str]									=							False




							def 		__snake_case(  self				:   List[str] )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    MobileNetVaModelTester(self )
												SCREAMING_SNAKE_CASE           =    MobileNetVaConfigTester(self		,							config_class=_UpperCamelCase		,							has_text_modality=_UpperCamelCase )




							def 		__snake_case(  self				:   Union[str, Any] )   ->			List[Any]:



												'''simple docstring'''

												self.config_tester.run_common_tests()




							@unittest.skip(reason="MobileNetV1 does not use inputs_embeds" )
							def 		__snake_case(  self				:   Tuple )   ->			Tuple:



												'''simple docstring'''

												pass




							@unittest.skip(reason="MobileNetV1 does not support input and output embeddings" )
							def 		__snake_case(  self				:   Optional[int] )   ->			Dict:



												'''simple docstring'''

												pass




							@unittest.skip(reason="MobileNetV1 does not output attentions" )
							def 		__snake_case(  self				:   Any )   ->			List[str]:



												'''simple docstring'''

												pass




							def 		__snake_case(  self				:   List[Any] )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	SCREAMING_SNAKE_CASE           =    model_class(_UpperCamelCase )
																	SCREAMING_SNAKE_CASE           =    inspect.signature(model.forward )
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	SCREAMING_SNAKE_CASE           =    [*signature.parameters.keys()]

																	SCREAMING_SNAKE_CASE           =    ["pixel_values"]
																	self.assertListEqual(arg_names[:1]		,							_UpperCamelCase )




							def 		__snake_case(  self				:   List[Any] )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase )




							def 		__snake_case(  self				:   List[str] )   ->			Optional[int]:



												'''simple docstring'''

												def check_hidden_states_output(_UpperCamelCase				:   Any		,							_UpperCamelCase				:   Dict		,							_UpperCamelCase				:   Tuple ):
																	SCREAMING_SNAKE_CASE           =    model_class(_UpperCamelCase )
																	model.to(_UpperCamelCase )
																	model.eval()

																	with torch.no_grad():
																						SCREAMING_SNAKE_CASE           =    model(**self._prepare_for_class(_UpperCamelCase		,							_UpperCamelCase ) )

																	SCREAMING_SNAKE_CASE           =    outputs.hidden_states

																	SCREAMING_SNAKE_CASE           =    26
																	self.assertEqual(len(_UpperCamelCase )		,							_UpperCamelCase )

												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	SCREAMING_SNAKE_CASE           =    True
																	check_hidden_states_output(_UpperCamelCase		,							_UpperCamelCase		,							_UpperCamelCase )

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	SCREAMING_SNAKE_CASE           =    True

																	check_hidden_states_output(_UpperCamelCase		,							_UpperCamelCase		,							_UpperCamelCase )




							def 		__snake_case(  self				:   Any )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase )





							@slow
							def 		__snake_case(  self				:   int )   ->			str:



												'''simple docstring'''

												for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	SCREAMING_SNAKE_CASE           =    MobileNetVaModel.from_pretrained(_UpperCamelCase )
																	self.assertIsNotNone(_UpperCamelCase )





def 		__lowerCamelCase							():
					SCREAMING_SNAKE_CASE           =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
					return image


@require_torch
@require_vision
class   lowercase      (       unittest.TestCase       ):




							@cached_property
							def 		__snake_case(  self				:   List[Any] )   ->			Optional[int]:



												'''simple docstring'''

												return (
												    MobileNetVaImageProcessor.from_pretrained("google/mobilenet_v1_1.0_224" ) if is_vision_available() else None
												)





							@slow
							def 		__snake_case(  self				:   str )   ->			Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    MobileNetVaForImageClassification.from_pretrained("google/mobilenet_v1_1.0_224" ).to(_UpperCamelCase )

												SCREAMING_SNAKE_CASE           =    self.default_image_processor
												SCREAMING_SNAKE_CASE           =    prepare_img()
												SCREAMING_SNAKE_CASE           =    image_processor(images=_UpperCamelCase		,							return_tensors="pt" ).to(_UpperCamelCase )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    model(**_UpperCamelCase )

												# verify the logits
												SCREAMING_SNAKE_CASE           =    torch.Size((1, 1_001) )
												self.assertEqual(outputs.logits.shape		,							_UpperCamelCase )

												SCREAMING_SNAKE_CASE           =    torch.tensor([-4.1_7_3_9, -1.1_2_3_3, 3.1_2_0_5] ).to(_UpperCamelCase )

												self.assertTrue(torch.allclose(outputs.logits[0, :3]		,							_UpperCamelCase		,							atol=1e-4 ) )




