





'''simple docstring'''

import datasets

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


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

UpperCAmelCase					:		str		=							'\\nBLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.\nQuality 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,\nthe 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\nremains one of the most popular automated and inexpensive metrics.\n\nScores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.\nThose scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality. Intelligibility or grammatical correctness\nare not taken into account[citation needed].\n\nBLEU\'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\nrepresenting 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\nreference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional\nreference translations will increase the BLEU score.\n'

UpperCAmelCase					:		Optional[int]		=							'\nComputes BLEU score of translated segments against one or more references.\nArgs:\n    predictions: list of translations to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    max_order: Maximum n-gram order to use when computing BLEU score.\n    smooth: Whether or not to apply Lin et al. 2004 smoothing.\nReturns:\n    \'bleu\': bleu score,\n    \'precisions\': geometric mean of n-gram precisions,\n    \'brevity_penalty\': brevity penalty,\n    \'length_ratio\': ratio of lengths,\n    \'translation_length\': translation_length,\n    \'reference_length\': reference_length\nExamples:\n\n    >>> predictions = [\n    ...     ["hello", "there", "general", "kenobi"],                             # tokenized prediction of the first sample\n    ...     ["foo", "bar", "foobar"]                                             # tokenized prediction of the second sample\n    ... ]\n    >>> references = [\n    ...     [["hello", "there", "general", "kenobi"], ["hello", "there", "!"]],  # tokenized references for the first sample (2 references)\n    ...     [["foo", "bar", "foobar"]]                                           # tokenized references for the second sample (1 reference)\n    ... ]\n    >>> bleu = datasets.load_metric("bleu")\n    >>> results = bleu.compute(predictions=predictions, references=references)\n    >>> print(results["bleu"])\n    1.0\n'





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







  def 				UpperCAmelCase_				(		self		)		->						Optional[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 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__     ,     lowercase__=4     ,     lowercase__=False		)		->						Dict:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     compute_bleu(
            reference_corpus=lowercase__     ,     translation_corpus=lowercase__     ,     max_order=lowercase__     ,     smooth=lowercase__		)
        ((_snake_case)     ,							(_snake_case)     ,							(_snake_case)     ,							(_snake_case)     ,							(_snake_case)     ,							(_snake_case))		:	str					     =     score
        return {
            "bleu": bleu,
            "precisions": precisions,
            "brevity_penalty": bp,
            "length_ratio": ratio,
            "translation_length": translation_length,
            "reference_length": reference_length,
        }









'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
   import tensorflow as tf

   from transformers import TFLEDForConditionalGeneration, TFLEDModel





@require_tf
class lowerCamelCase						:
  _lowercase  :	Any       					=				LEDConfig
  _lowercase  :	Any       					=				{}
  _lowercase  :	Optional[Any]       					=				"""gelu"""







  def __init__(		self     ,     lowercase__     ,     lowercase__=13     ,     lowercase__=7     ,     lowercase__=True     ,     lowercase__=False     ,     lowercase__=99     ,     lowercase__=32     ,     lowercase__=2     ,     lowercase__=4     ,     lowercase__=37     ,     lowercase__=0.1     ,     lowercase__=0.1     ,     lowercase__=20     ,     lowercase__=2     ,     lowercase__=1     ,     lowercase__=0     ,     lowercase__=4     ,     )		->						Any:






        """simple docstring"""





        _snake_case		:	Dict					     =     parent
        _snake_case		:	Any					     =     batch_size
        _snake_case		:	List[str]					     =     seq_length
        _snake_case		:	Union[str, Any]					     =     is_training
        _snake_case		:	Tuple					     =     use_labels
        _snake_case		:	int					     =     vocab_size
        _snake_case		:	str					     =     hidden_size
        _snake_case		:	Optional[Any]					     =     num_hidden_layers
        _snake_case		:	List[Any]					     =     num_attention_heads
        _snake_case		:	Optional[int]					     =     intermediate_size

        _snake_case		:	List[Any]					     =     hidden_dropout_prob
        _snake_case		:	List[str]					     =     attention_probs_dropout_prob
        _snake_case		:	Optional[int]					     =     max_position_embeddings
        _snake_case		:	Any					     =     eos_token_id
        _snake_case		:	List[Any]					     =     pad_token_id
        _snake_case		:	Optional[int]					     =     bos_token_id
        _snake_case		:	Any					     =     attention_window

        # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
        # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
        # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
        # because its local attention only attends to `self.attention_window` and one before and one after
        _snake_case		:	Any					     =     self.attention_window + 2

        # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
        # the `test_attention_outputs` and `test_hidden_states_output` tests
        _snake_case		:	Tuple					     =     (
            self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
        )







  def 				UpperCAmelCase_				(		self		)		->						Optional[int]:






        """simple docstring"""





        _snake_case		:	Optional[int]					     =     ids_tensor([self.batch_size, self.seq_length - 1]     ,     self.vocab_size		)
        _snake_case		:	Tuple					     =     tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size		)     ,     1		)
        _snake_case		:	Optional[int]					     =     tf.concat([input_ids, eos_tensor]     ,     axis=1		)

        _snake_case		:	Union[str, Any]					     =     ids_tensor([self.batch_size, self.seq_length]     ,     self.vocab_size		)

        _snake_case		:	List[Any]					     =     self.config_cls(
            vocab_size=self.vocab_size     ,     d_model=self.hidden_size     ,     encoder_layers=self.num_hidden_layers     ,     decoder_layers=self.num_hidden_layers     ,     encoder_attention_heads=self.num_attention_heads     ,     decoder_attention_heads=self.num_attention_heads     ,     encoder_ffn_dim=self.intermediate_size     ,     decoder_ffn_dim=self.intermediate_size     ,     dropout=self.hidden_dropout_prob     ,     attention_dropout=self.attention_probs_dropout_prob     ,     max_position_embeddings=self.max_position_embeddings     ,     eos_token_ids=[2]     ,     bos_token_id=self.bos_token_id     ,     pad_token_id=self.pad_token_id     ,     decoder_start_token_id=self.pad_token_id     ,     attention_window=self.attention_window     ,     **self.config_updates     ,     )
        _snake_case		:	Dict					     =     prepare_led_inputs_dict(lowercase__     ,     lowercase__     ,     lowercase__		)
        _snake_case		:	Dict					     =     tf.concat(
            [tf.zeros_like(lowercase__		)[:, :-1], tf.ones_like(lowercase__		)[:, -1:]]     ,     axis=-1     ,     )
        _snake_case		:	Dict					     =     global_attention_mask
        return config, inputs_dict







  def 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__		)		->						int:






        """simple docstring"""





        _snake_case		:	int					     =     TFLEDModel(config=lowercase__		).get_decoder()
        _snake_case		:	Union[str, Any]					     =     inputs_dict['''input_ids''']

        _snake_case		:	List[str]					     =     input_ids[:1, :]
        _snake_case		:	Tuple					     =     inputs_dict['''attention_mask'''][:1, :]
        _snake_case		:	Dict					     =     1

        # first forward pass
        _snake_case		:	Optional[int]					     =     model(lowercase__     ,     attention_mask=lowercase__     ,     use_cache=lowercase__		)

        _snake_case     ,							_snake_case		:	Dict					     =     outputs.to_tuple()

        # create hypothetical next token and extent to next_input_ids
        _snake_case		:	Optional[int]					     =     ids_tensor((self.batch_size, 3)     ,     config.vocab_size		)
        _snake_case		:	Any					     =     tf.cast(ids_tensor((self.batch_size, 3)     ,     2		)     ,     tf.inta		)

        # append to next input_ids and
        _snake_case		:	Tuple					     =     tf.concat([input_ids, next_tokens]     ,     axis=-1		)
        _snake_case		:	List[Any]					     =     tf.concat([attention_mask, next_attn_mask]     ,     axis=-1		)

        _snake_case		:	List[Any]					     =     model(lowercase__     ,     attention_mask=lowercase__		)[0]
        _snake_case		:	Tuple					     =     model(lowercase__     ,     attention_mask=lowercase__     ,     past_key_values=lowercase__		)[0]

        self.parent.assertEqual(next_tokens.shape[1]     ,     output_from_past.shape[1]		)

        # select random slice
        _snake_case		:	Tuple					     =     int(ids_tensor((1,)     ,     output_from_past.shape[-1]		)		)
        _snake_case		:	int					     =     output_from_no_past[:, -3:, random_slice_idx]
        _snake_case		:	Optional[Any]					     =     output_from_past[:, :, random_slice_idx]

        # test that outputs are equal for slice
        tf.debugging.assert_near(lowercase__     ,     lowercase__     ,     rtol=1E-3		)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_=None			,      lowerCAmelCase_=None			,      lowerCAmelCase_=None			,      lowerCAmelCase_=None			,      ):





      """simple docstring"""



      if attention_mask is None:
            _snake_case		:	Union[str, Any]					     =     tf.cast(tf.math.not_equal(lowerCAmelCase_			,      config.pad_token_id	)			,      tf.inta	)
      if decoder_attention_mask is None:
            _snake_case		:	str					     =     tf.concat(
                [
                    tf.ones(decoder_input_ids[:, :1].shape			,      dtype=tf.inta	),
                    tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]			,      config.pad_token_id	)			,      tf.inta	),
                ]			,      axis=-1			,      )
      if head_mask is None:
            _snake_case		:	int					     =     tf.ones((config.encoder_layers, config.encoder_attention_heads)	)
      if decoder_head_mask is None:
            _snake_case		:	List[str]					     =     tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
      return {
          "input_ids": input_ids,
          "attention_mask": attention_mask,
          "decoder_input_ids": decoder_input_ids,
          "decoder_attention_mask": decoder_attention_mask,
          "head_mask": head_mask,
          "decoder_head_mask": decoder_head_mask,
      }





@require_tf
class lowerCamelCase						(a__						,      a__						,      unittest.TestCase					):
  _lowercase  :	Optional[int]       					=				(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
  _lowercase  :	int       					=				(TFLEDForConditionalGeneration,) if is_tf_available() else ()
  _lowercase  :	Dict       					=				(
      {
          """conversational""": TFLEDForConditionalGeneration,
          """feature-extraction""": TFLEDModel,
          """summarization""": TFLEDForConditionalGeneration,
          """text2text-generation""": TFLEDForConditionalGeneration,
          """translation""": TFLEDForConditionalGeneration,
      }
      if is_tf_available()
      else {}
  )
  _lowercase  :	int       					=				True
  _lowercase  :	List[Any]       					=				False
  _lowercase  :	str       					=				False
  _lowercase  :	Union[str, Any]       					=				False







  def 				UpperCAmelCase_				(		self		)		->						Optional[Any]:






        """simple docstring"""





        _snake_case		:	str					     =     TFLEDModelTester(self		)
        _snake_case		:	Union[str, Any]					     =     ConfigTester(self     ,     config_class=lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        self.config_tester.run_common_tests()







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






        """simple docstring"""





        _snake_case		:	List[Any]					     =     self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        _snake_case     ,							_snake_case		:	List[Any]					     =     self.model_tester.prepare_config_and_inputs_for_common()
        _snake_case		:	Any					     =     tf.zeros_like(inputs_dict['''attention_mask''']		)
        _snake_case		:	Optional[Any]					     =     2
        _snake_case		:	Any					     =     tf.where(
            tf.range(self.model_tester.seq_length		)[None, :] < num_global_attn_indices     ,     1     ,     inputs_dict['''global_attention_mask''']     ,     )

        _snake_case		:	Dict					     =     True
        _snake_case		:	str					     =     self.model_tester.seq_length
        _snake_case		:	Dict					     =     self.model_tester.encoder_seq_length

        def check_decoder_attentions_output(lowercase__		):
              _snake_case		:	Optional[int]					     =     outputs.decoder_attentions
              self.assertEqual(len(lowercase__		)     ,     self.model_tester.num_hidden_layers		)
              self.assertListEqual(
                  list(decoder_attentions[0].shape[-3:]		)     ,     [self.model_tester.num_attention_heads, seq_length, seq_length]     ,     )

        def check_encoder_attentions_output(lowercase__		):
              _snake_case		:	int					     =     [t.numpy() for t in outputs.encoder_attentions]
              _snake_case		:	Tuple					     =     [t.numpy() for t in outputs.encoder_global_attentions]
              self.assertEqual(len(lowercase__		)     ,     self.model_tester.num_hidden_layers		)
              self.assertEqual(len(lowercase__		)     ,     self.model_tester.num_hidden_layers		)
              self.assertListEqual(
                  list(attentions[0].shape[-3:]		)     ,     [self.model_tester.num_attention_heads, seq_length, seq_length]     ,     )
              self.assertListEqual(
                  list(global_attentions[0].shape[-3:]		)     ,     [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]     ,     )

        for model_class in self.all_model_classes:
              _snake_case		:	Union[str, Any]					     =     True
              _snake_case		:	Dict					     =     False
              _snake_case		:	Union[str, Any]					     =     False
              _snake_case		:	List[Any]					     =     model_class(lowercase__		)
              _snake_case		:	Optional[Any]					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)
              _snake_case		:	List[Any]					     =     len(lowercase__		)
              self.assertEqual(config.output_hidden_states     ,     lowercase__		)
              check_encoder_attentions_output(lowercase__		)

              if self.is_encoder_decoder:
                    _snake_case		:	Union[str, Any]					     =     model_class(lowercase__		)
                    _snake_case		:	List[Any]					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)
                    self.assertEqual(config.output_hidden_states     ,     lowercase__		)
                    check_decoder_attentions_output(lowercase__		)

              # Check that output attentions can also be changed via the config
              del inputs_dict["output_attentions"]
              _snake_case		:	str					     =     True
              _snake_case		:	Tuple					     =     model_class(lowercase__		)
              _snake_case		:	int					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)
              self.assertEqual(config.output_hidden_states     ,     lowercase__		)
              check_encoder_attentions_output(lowercase__		)

              # Check attention is always last and order is fine
              _snake_case		:	int					     =     True
              _snake_case		:	List[str]					     =     True
              _snake_case		:	Tuple					     =     model_class(lowercase__		)
              _snake_case		:	Optional[Any]					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)

              self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)     ,     len(lowercase__		)		)
              self.assertEqual(model.config.output_hidden_states     ,     lowercase__		)
              check_encoder_attentions_output(lowercase__		)







  @unittest.skip('''LED keeps using potentially symbolic tensors in conditionals and breaks tracing.'''		)
  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        pass







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        pass




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      return tf.constant(lowerCAmelCase_			,      dtype=tf.intaa	)


UpperCAmelCase					:		Dict		=							1E-4





@slow
@require_tf
class lowerCamelCase						(unittest.TestCase					):







  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        _snake_case		:	List[str]					     =     TFLEDForConditionalGeneration.from_pretrained('''allenai/led-base-16384'''		).led

        # change to intended input here
        _snake_case		:	List[str]					     =     _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	Tuple					     =     _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	Tuple					     =     prepare_led_inputs_dict(model.config     ,     lowercase__     ,     lowercase__		)
        _snake_case		:	int					     =     model(**lowercase__		)[0]
        _snake_case		:	Dict					     =     (1, 1_024, 768)
        self.assertEqual(output.shape     ,     lowercase__		)
        # change to expected output here
        _snake_case		:	List[Any]					     =     tf.convert_to_tensor(
            [[2.3_050, 2.8_279, 0.6_531], [-1.8_457, -0.1_455, -3.5_661], [-1.0_186, 0.4_586, -2.2_043]]     ,     )
        tf.debugging.assert_near(output[:, :3, :3]     ,     lowercase__     ,     atol=1E-3		)







  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	Any					     =     TFLEDForConditionalGeneration.from_pretrained('''allenai/led-base-16384'''		)

        # change to intended input here
        _snake_case		:	Dict					     =     _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	Dict					     =     _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	List[str]					     =     prepare_led_inputs_dict(model.config     ,     lowercase__     ,     lowercase__		)
        _snake_case		:	Tuple					     =     model(**lowercase__		)[0]
        _snake_case		:	Any					     =     (1, 1_024, model.config.vocab_size)
        self.assertEqual(output.shape     ,     lowercase__		)
        # change to expected output here
        _snake_case		:	Dict					     =     tf.convert_to_tensor(
            [[33.6_507, 6.4_572, 16.8_089], [5.8_739, -2.4_238, 11.2_902], [-3.2_139, -4.3_149, 4.2_783]]     ,     )
        tf.debugging.assert_near(output[:, :3, :3]     ,     lowercase__     ,     atol=1E-3     ,     rtol=1E-3		)


