






'''simple docstring'''






import datasets

from .nmt_bleu import compute_bleu  # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py


__A    	=   '''\
@INPROCEEDINGS{Papineni02bleu:a,
    author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu},
    title = {BLEU: a Method for Automatic Evaluation of Machine Translation},
    booktitle = {},
    year = {2002},
    pages = {311--318}
}
@inproceedings{lin-och-2004-orange,
    title = "{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation",
    author = "Lin, Chin-Yew  and
      Och, Franz Josef",
    booktitle = "{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics",
    month = "aug 23{--}aug 27",
    year = "2004",
    address = "Geneva, Switzerland",
    publisher = "COLING",
    url = "https://www.aclweb.org/anthology/C04-1072",
    pages = "501--507",
}
'''

__A    	=   '''\
BLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.
Quality is considered to be the correspondence between a machine\'s output and that of a human: "the closer a machine translation is to a professional human translation,
the better it is" – this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and
remains one of the most popular automated and inexpensive metrics.

Scores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.
Those scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality. Intelligibility or grammatical correctness
are not taken into account[citation needed].

BLEU\'s output is always a number between 0 and 1. This value indicates how similar the candidate text is to the reference texts, with values closer to 1
representing more similar texts. Few human translations will attain a score of 1, since this would indicate that the candidate is identical to one of the
reference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional
reference translations will increase the BLEU score.
'''

__A    	=   '''
Computes BLEU score of translated segments against one or more references.
Args:
    predictions: list of translations to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    max_order: Maximum n-gram order to use when computing BLEU score.
    smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
    \'bleu\': bleu score,
    \'precisions\': geometric mean of n-gram precisions,
    \'brevity_penalty\': brevity penalty,
    \'length_ratio\': ratio of lengths,
    \'translation_length\': translation_length,
    \'reference_length\': reference_length
Examples:

    >>> predictions = [
    ...     ["hello", "there", "general", "kenobi"],                             # tokenized prediction of the first sample
    ...     ["foo", "bar", "foobar"]                                             # tokenized prediction of the second sample
    ... ]
    >>> references = [
    ...     [["hello", "there", "general", "kenobi"], ["hello", "there", "!"]],  # tokenized references for the first sample (2 references)
    ...     [["foo", "bar", "foobar"]]                                           # tokenized references for the second sample (1 reference)
    ... ]
    >>> bleu = datasets.load_metric("bleu")
    >>> results = bleu.compute(predictions=predictions, references=references)
    >>> print(results["bleu"])
    1.0
'''




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







   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """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'),
              })					,   codebase_urls=['https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py']					,   reference_urls=[
              'https://en.wikipedia.org/wiki/BLEU',
              'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213',
          ]					,   )







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a=4					,   __a=False)			->      Any:
      """simple docstring"""






      __snake_case				:      Dict     							= compute_bleu(
          reference_corpus=__a					,   translation_corpus=__a					,   max_order=__a					,   smooth=__a)
      (__snake_case)				:      Dict     							= score
      return {
          "bleu": bleu,
          "precisions": precisions,
          "brevity_penalty": bp,
          "length_ratio": ratio,
          "translation_length": translation_length,
          "reference_length": reference_length,
      }







'''simple docstring'''






import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TFEfficientFormerForImageClassification,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerModel,
      )
      from transformers.models.efficientformer.modeling_tf_efficientformer import (
          TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_vision_available():
      from PIL import Image

      from transformers import EfficientFormerImageProcessor




class a_    :







   def __init__(self					,   __a					,   __a = 1_3					,   __a = 6_4					,   __a = 2					,   __a = 3					,   __a = 3					,   __a = True					,   __a = True					,   __a = 1_2_8					,   __a=[1_6, 3_2, 6_4, 1_2_8]					,   __a = 7					,   __a = 4					,   __a = 3_7					,   __a = "gelu"					,   __a = 0.1					,   __a = 0.1					,   __a = 1_0					,   __a = 0.02					,   __a = 2					,   __a = 1					,   __a = 1_2_8					,   __a = [2, 2, 2, 2]					,   __a = 2					,   __a = 2					,   )			->      str:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= parent
      __snake_case				:      Optional[int]     							= batch_size
      __snake_case				:      Optional[Any]     							= image_size
      __snake_case				:      Optional[int]     							= patch_size
      __snake_case				:      Optional[Any]     							= num_channels
      __snake_case				:      Optional[Any]     							= is_training
      __snake_case				:      Tuple     							= use_labels
      __snake_case				:      Optional[int]     							= hidden_size
      __snake_case				:      Any     							= num_hidden_layers
      __snake_case				:      List[str]     							= num_attention_heads
      __snake_case				:      Tuple     							= intermediate_size
      __snake_case				:      List[str]     							= hidden_act
      __snake_case				:      Dict     							= hidden_dropout_prob
      __snake_case				:      Any     							= attention_probs_dropout_prob
      __snake_case				:      Dict     							= type_sequence_label_size
      __snake_case				:      str     							= initializer_range
      __snake_case				:      int     							= encoder_stride
      __snake_case				:      List[str]     							= num_attention_outputs
      __snake_case				:      Optional[Any]     							= embed_dim
      __snake_case				:      Optional[Any]     							= embed_dim + 1
      __snake_case				:      List[str]     							= resolution
      __snake_case				:      Optional[int]     							= depths
      __snake_case				:      List[Any]     							= hidden_sizes
      __snake_case				:      List[str]     							= dim
      __snake_case				:      Union[str, Any]     							= mlp_expansion_ratio







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      __snake_case				:      List[str]     							= None
      if self.use_labels:
         __snake_case				:      Optional[int]     							= ids_tensor([self.batch_size]					,   self.type_sequence_label_size)

      __snake_case				:      Tuple     							= self.get_config()

      return config, pixel_values, labels







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
      """simple docstring"""






      return EfficientFormerConfig(
          image_size=self.image_size					,   patch_size=self.patch_size					,   num_channels=self.num_channels					,   hidden_size=self.hidden_size					,   num_hidden_layers=self.num_hidden_layers					,   num_attention_heads=self.num_attention_heads					,   intermediate_size=self.intermediate_size					,   hidden_act=self.hidden_act					,   hidden_dropout_prob=self.hidden_dropout_prob					,   attention_probs_dropout_prob=self.attention_probs_dropout_prob					,   is_decoder=__a					,   initializer_range=self.initializer_range					,   encoder_stride=self.encoder_stride					,   resolution=self.resolution					,   depths=self.depths					,   hidden_sizes=self.hidden_sizes					,   dim=self.dim					,   mlp_expansion_ratio=self.mlp_expansion_ratio					,   )







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Optional[int]:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= TFEfficientFormerModel(config=__a)
      __snake_case				:      int     							= model(__a					,   training=__a)
      self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size))







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Tuple:
      """simple docstring"""






      __snake_case				:      Dict     							= self.type_sequence_label_size
      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassification(__a)
      __snake_case				:      Optional[int]     							= model(__a					,   labels=__a					,   training=__a)
      self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size))

      # test greyscale images
      __snake_case				:      List[Any]     							= 1
      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassification(__a)

      __snake_case				:      List[str]     							= floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
      __snake_case				:      str     							= model(__a					,   labels=__a)
      self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size))







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= self.prepare_config_and_inputs()
      __snake_case							,__snake_case							,__snake_case				:      Union[str, Any]     							= config_and_inputs
      __snake_case				:      Optional[int]     							= {'pixel_values': pixel_values}
      return config, inputs_dict




@require_tf
class a_    (    UpperCamelCase_		,      UpperCamelCase_		,      unittest.TestCase							):
   _snake_case        =							(
       (
           TFEfficientFormerModel,
           TFEfficientFormerForImageClassificationWithTeacher,
           TFEfficientFormerForImageClassification,
       )
       if is_tf_available()
       else ()
   )
   _snake_case        =							(
       {
           """feature-extraction""": TFEfficientFormerModel,
           """image-classification""": (
               TFEfficientFormerForImageClassification,
               TFEfficientFormerForImageClassificationWithTeacher,
           ),
       }
       if is_tf_available()
       else {}
   )

   _snake_case        =							False

   _snake_case        =							False
   _snake_case        =							False
   _snake_case        =							False
   _snake_case        =							False







   def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
      """simple docstring"""






      __snake_case				:      Dict     							= TFEfficientFormerModelTester(self)
      __snake_case				:      List[Any]     							= ConfigTester(
          self					,   config_class=__a					,   has_text_modality=__a					,   hidden_size=3_7)







   def     SCREAMING_SNAKE_CASE__					(self)			->      str:
      """simple docstring"""






      self.config_tester.run_common_tests()







   @unittest.skip(reason='EfficientFormer does not use inputs_embeds')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      pass







   @unittest.skip(reason='EfficientFormer does not support input and output embeddings')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      pass







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      """simple docstring"""






      __snake_case							,__snake_case				:      str     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __snake_case				:      Optional[int]     							= model_class(__a)
         __snake_case				:      Union[str, Any]     							= inspect.signature(model.call)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __snake_case				:      Optional[int]     							= [*signature.parameters.keys()]

         __snake_case				:      Dict     							= ['pixel_values']
         self.assertListEqual(arg_names[:1]					,   __a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[int]:
      """simple docstring"""






      def check_hidden_states_output(__a					,   __a					,   __a):
         __snake_case				:      str     							= model_class(__a)

         __snake_case				:      List[Any]     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)
         __snake_case				:      str     							= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         __snake_case				:      Optional[Any]     							= getattr(
             self.model_tester					,   'expected_num_hidden_layers'					,   self.model_tester.num_hidden_layers + 1)
         self.assertEqual(len(__a)					,   __a)

         if hasattr(self.model_tester					,   'encoder_seq_length'):
            __snake_case				:      List[Any]     							= self.model_tester.encoder_seq_length
            if hasattr(self.model_tester					,   'chunk_length') and self.model_tester.chunk_length > 1:
               __snake_case				:      str     							= seq_length * self.model_tester.chunk_length
         else:
            __snake_case				:      Optional[int]     							= self.model_tester.seq_length

         self.assertListEqual(
             list(hidden_states[-1].shape[-2:])					,   [seq_length, self.model_tester.hidden_size]					,   )

         if config.is_encoder_decoder:
            __snake_case				:      List[Any]     							= outputs.decoder_hidden_states

            self.asseretIsInstance(__a					,   (list, tuple))
            self.assertEqual(len(__a)					,   __a)
            __snake_case				:      List[str]     							= getattr(self.model_tester					,   'seq_length'					,   __a)
            __snake_case				:      Tuple     							= getattr(self.model_tester					,   'decoder_seq_length'					,   __a)

            self.assertListEqual(
                list(hidden_states[-1].shape[-2:])					,   [decoder_seq_length, self.model_tester.hidden_size]					,   )

      __snake_case							,__snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __snake_case				:      List[str]     							= True
         check_hidden_states_output(__a					,   __a					,   __a)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __snake_case				:      str     							= True

         check_hidden_states_output(__a					,   __a					,   __a)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a=False)			->      int:
      """simple docstring"""






      __snake_case				:      Optional[int]     							= super()._prepare_for_class(__a					,   __a					,   return_labels=__a)

      if return_labels:
         if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
            del inputs_dict["labels"]

      return inputs_dict







   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__a)







   @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






      __snake_case				:      int     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*__a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__a)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
      """simple docstring"""






      for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __snake_case				:      Any     							= TFEfficientFormerModel.from_pretrained(__a)
         self.assertIsNotNone(__a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






      __snake_case							,__snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()
      __snake_case				:      Tuple     							= True

      __snake_case				:      Optional[Any]     							= getattr(self.model_tester					,   'seq_length'					,   __a)
      __snake_case				:      List[Any]     							= getattr(self.model_tester					,   'encoder_seq_length'					,   __a)
      __snake_case				:      Tuple     							= getattr(self.model_tester					,   'key_length'					,   __a)
      __snake_case				:      Optional[Any]     							= getattr(self.model_tester					,   'chunk_length'					,   __a)

      if chunk_length is not None and hasattr(self.model_tester					,   'num_hashes'):
         __snake_case				:      str     							= encoder_seq_length * self.model_tester.num_hashes

      for model_class in self.all_model_classes:
         __snake_case				:      Optional[Any]     							= True
         __snake_case				:      Dict     							= False
         __snake_case				:      Optional[int]     							= True
         __snake_case				:      Dict     							= model_class(__a)

         __snake_case				:      Tuple     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)
         __snake_case				:      Union[str, Any]     							= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__a)					,   self.model_tester.num_attention_outputs)

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __snake_case				:      Dict     							= True
         __snake_case				:      str     							= model_class(__a)
         __snake_case				:      str     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)

         __snake_case				:      Tuple     							= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__a)					,   self.model_tester.num_attention_outputs)

         if chunk_length is not None:
            self.assertListEqual(
                list(attentions[0].shape[-4:])					,   [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]					,   )
         else:
            self.assertListEqual(
                list(attentions[0].shape[-3:])					,   [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,   )







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case							,__snake_case				:      Dict     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         # Prepare our model
         __snake_case				:      Tuple     							= model_class(__a)
         # These are maximally general inputs for the model, with multiple None dimensions
         # Hopefully this will catch any conditionals that fail for flexible shapes
         __snake_case				:      Optional[Any]     							= {
             key: tf.keras.Input(shape=val.shape[1:]					,   dtype=val.dtype					,   name=__a)
             for key, val in model.input_signature.items()
             if key in model.dummy_inputs
         }
         __snake_case				:      Tuple     							= model(__a)
         self.assertTrue(outputs_dict is not None)




def        _SCREAMING_SNAKE_CASE  (				)    -> int:







   """simple docstring"""
   __snake_case				:      Tuple     							= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
   return image





@require_tf
@require_vision
class a_    (    unittest.TestCase							):







   @cached_property
   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      return (
          EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300')
          if is_vision_available()
          else None
      )







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300')
      __snake_case				:      Optional[int]     							= self.default_image_processor
      __snake_case				:      List[Any]     							= prepare_img()
      __snake_case				:      List[Any]     							= image_processor(images=__a					,   return_tensors='tf')
      # forward pass
      __snake_case				:      List[str]     							= model(**__a					,   training=__a)
      # verify the logits
      __snake_case				:      str     							= tf.TensorShape((1, 1_0_0_0))
      self.assertEqual(outputs.logits.shape					,   __a)
      __snake_case				:      Any     							= tf.constant([-0.0_555, 0.4_825, -0.0_852])
      self.assertTrue(np.allclose(outputs.logits[0, :3]					,   __a					,   atol=1E-4))







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
          'snap-research/efficientformer-l1-300')
      __snake_case				:      List[Any]     							= self.default_image_processor
      __snake_case				:      Union[str, Any]     							= prepare_img()
      __snake_case				:      List[Any]     							= image_processor(images=__a					,   return_tensors='tf')
      # forward pass
      __snake_case				:      Optional[int]     							= model(**__a					,   training=__a)
      # verify the logits
      __snake_case				:      Optional[int]     							= tf.TensorShape((1, 1_0_0_0))
      self.assertEqual(outputs.logits.shape					,   __a)
      __snake_case				:      List[str]     							= tf.constant([-0.1_312, 0.4_353, -1.0_499])
      self.assertTrue(np.allclose(outputs.logits[0, :3]					,   __a					,   atol=1E-4))