



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 						UpperCAmelCase_					:
							lowerCamelCase__         =	LEDConfig
							lowerCamelCase__         =	{}
							lowerCamelCase__         =	'gelu'







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

														'''simple docstring'''

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

														_lowerCAmelCase  :							Union[str, Any]				     =					hidden_dropout_prob
														_lowerCAmelCase  :							int				     =					attention_probs_dropout_prob
														_lowerCAmelCase  :							Dict				     =					max_position_embeddings
														_lowerCAmelCase  :							List[str]				     =					eos_token_id
														_lowerCAmelCase  :							Optional[int]				     =					pad_token_id
														_lowerCAmelCase  :							str				     =					bos_token_id
														_lowerCAmelCase  :							str				     =					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
														_lowerCAmelCase  :							Dict				     =					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
														_lowerCAmelCase  :							Optional[int]				     =					(
														    self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
														)







							def      snake_case__   (     self):

														'''simple docstring'''

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

														_lowerCAmelCase  :							List[Any]				     =					ids_tensor([self.batch_size, self.seq_length],    self.vocab_size)

														_lowerCAmelCase  :							Optional[int]				     =					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,    )
														_lowerCAmelCase  :							Optional[int]				     =					prepare_led_inputs_dict(__a,    __a,    __a)
														_lowerCAmelCase  :							List[str]				     =					tf.concat(
														    [tf.zeros_like(__a)[:, :-1], tf.ones_like(__a)[:, -1:]],    axis=-1,    )
														_lowerCAmelCase  :							str				     =					global_attention_mask
														return config, inputs_dict







							def      snake_case__   (     self,    __a,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							List[str]				     =					TFLEDModel(config=__a).get_decoder()
														_lowerCAmelCase  :							int				     =					inputs_dict["input_ids"]

														_lowerCAmelCase  :							Tuple				     =					input_ids[:1, :]
														_lowerCAmelCase  :							Union[str, Any]				     =					inputs_dict["attention_mask"][:1, :]
														_lowerCAmelCase  :							Any				     =					1

														# first forward pass
														_lowerCAmelCase  :							Tuple				     =					model(__a,    attention_mask=__a,    use_cache=__a)

														_lowerCAmelCase     ,					_lowerCAmelCase  :							Union[str, Any]				     =					outputs.to_tuple()

														# create hypothetical next token and extent to next_input_ids
														_lowerCAmelCase  :							List[str]				     =					ids_tensor((self.batch_size, 3),    config.vocab_size)
														_lowerCAmelCase  :							Tuple				     =					tf.cast(ids_tensor((self.batch_size, 3),    2),    tf.inta)

														# append to next input_ids and
														_lowerCAmelCase  :							Dict				     =					tf.concat([input_ids, next_tokens],    axis=-1)
														_lowerCAmelCase  :							str				     =					tf.concat([attention_mask, next_attn_mask],    axis=-1)

														_lowerCAmelCase  :							str				     =					model(__a,    attention_mask=__a)[0]
														_lowerCAmelCase  :							Optional[int]				     =					model(__a,    attention_mask=__a,    past_key_values=__a)[0]

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

														# select random slice
														_lowerCAmelCase  :							Dict				     =					int(ids_tensor((1,),    output_from_past.shape[-1]))
														_lowerCAmelCase  :							str				     =					output_from_no_past[:, -3:, random_slice_idx]
														_lowerCAmelCase  :							Any				     =					output_from_past[:, :, random_slice_idx]

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






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase=None       ,				_lowerCamelCase=None       ,				_lowerCamelCase=None       ,				_lowerCamelCase=None       ,				):





							'''simple docstring'''




							if attention_mask is None:
														_lowerCAmelCase  :							Dict				     =					tf.cast(tf.math.not_equal(_lowerCamelCase       ,				config.pad_token_id						)       ,				tf.inta						)
							if decoder_attention_mask is None:
														_lowerCAmelCase  :							Optional[Any]				     =					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:
														_lowerCAmelCase  :							Tuple				     =					tf.ones((config.encoder_layers, config.encoder_attention_heads)						)
							if decoder_head_mask is None:
														_lowerCAmelCase  :							Optional[Any]				     =					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 						UpperCAmelCase_					( a     ,      a     ,      unittest.TestCase):
							lowerCamelCase__         =	(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
							lowerCamelCase__         =	(TFLEDForConditionalGeneration,) if is_tf_available() else ()
							lowerCamelCase__         =	(
							    {
							        'conversational': TFLEDForConditionalGeneration,
							        'feature-extraction': TFLEDModel,
							        'summarization': TFLEDForConditionalGeneration,
							        'text2text-generation': TFLEDForConditionalGeneration,
							        'translation': TFLEDForConditionalGeneration,
							    }
							    if is_tf_available()
							    else {}
							)
							lowerCamelCase__         =	True
							lowerCamelCase__         =	False
							lowerCamelCase__         =	False
							lowerCamelCase__         =	False







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					TFLEDModelTester(self)
														_lowerCAmelCase  :							Any				     =					ConfigTester(self,    config_class=__a)







							def      snake_case__   (     self):

														'''simple docstring'''

														self.config_tester.run_common_tests()







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Dict				     =					self.model_tester.prepare_config_and_inputs_for_common()
														self.model_tester.check_decoder_model_past_large_inputs(*__a)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase     ,					_lowerCAmelCase  :							Optional[int]				     =					self.model_tester.prepare_config_and_inputs_for_common()
														_lowerCAmelCase  :							Dict				     =					tf.zeros_like(inputs_dict["attention_mask"])
														_lowerCAmelCase  :							Tuple				     =					2
														_lowerCAmelCase  :							Tuple				     =					tf.where(
														    tf.range(self.model_tester.seq_length)[None, :] < num_global_attn_indices,    1,    inputs_dict["global_attention_mask"],    )

														_lowerCAmelCase  :							Tuple				     =					True
														_lowerCAmelCase  :							Any				     =					self.model_tester.seq_length
														_lowerCAmelCase  :							Any				     =					self.model_tester.encoder_seq_length

														def check_decoder_attentions_output(__a):
																					_lowerCAmelCase  :							Optional[int]				     =					outputs.decoder_attentions
																					self.assertEqual(len(__a),    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(__a):
																					_lowerCAmelCase  :							List[str]				     =					[t.numpy() for t in outputs.encoder_attentions]
																					_lowerCAmelCase  :							int				     =					[t.numpy() for t in outputs.encoder_global_attentions]
																					self.assertEqual(len(__a),    self.model_tester.num_hidden_layers)
																					self.assertEqual(len(__a),    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:
																					_lowerCAmelCase  :							Tuple				     =					True
																					_lowerCAmelCase  :							int				     =					False
																					_lowerCAmelCase  :							Dict				     =					False
																					_lowerCAmelCase  :							Optional[int]				     =					model_class(__a)
																					_lowerCAmelCase  :							Dict				     =					model(self._prepare_for_class(__a,    __a))
																					_lowerCAmelCase  :							str				     =					len(__a)
																					self.assertEqual(config.output_hidden_states,    __a)
																					check_encoder_attentions_output(__a)

																					if self.is_encoder_decoder:
																												_lowerCAmelCase  :							Optional[Any]				     =					model_class(__a)
																												_lowerCAmelCase  :							Union[str, Any]				     =					model(self._prepare_for_class(__a,    __a))
																												self.assertEqual(config.output_hidden_states,    __a)
																												check_decoder_attentions_output(__a)

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

																					# Check attention is always last and order is fine
																					_lowerCAmelCase  :							int				     =					True
																					_lowerCAmelCase  :							Any				     =					True
																					_lowerCAmelCase  :							Dict				     =					model_class(__a)
																					_lowerCAmelCase  :							Optional[int]				     =					model(self._prepare_for_class(__a,    __a))

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







							@unittest.skip("LED keeps using potentially symbolic tensors in conditionals and breaks tracing.")
							def      snake_case__   (     self):

														'''simple docstring'''

														pass







							def      snake_case__   (     self):

														'''simple docstring'''

														pass






def        A       (      _lowerCamelCase						):





							'''simple docstring'''




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


_snake_case	=						1e-4



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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384").led

														# change to intended input here
														_lowerCAmelCase  :							int				     =					_long_tensor([512 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]])
														_lowerCAmelCase  :							Optional[int]				     =					_long_tensor([128 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]])
														_lowerCAmelCase  :							Dict				     =					prepare_led_inputs_dict(model.config,    __a,    __a)
														_lowerCAmelCase  :							Optional[Any]				     =					model(**__a)[0]
														_lowerCAmelCase  :							Any				     =					(1, 1024, 768)
														self.assertEqual(output.shape,    __a)
														# change to expected output here
														_lowerCAmelCase  :							str				     =					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],    __a,    atol=1E-3)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Tuple				     =					TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")

														# change to intended input here
														_lowerCAmelCase  :							List[str]				     =					_long_tensor([512 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]])
														_lowerCAmelCase  :							Tuple				     =					_long_tensor([128 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]])
														_lowerCAmelCase  :							Optional[int]				     =					prepare_led_inputs_dict(model.config,    __a,    __a)
														_lowerCAmelCase  :							Optional[Any]				     =					model(**__a)[0]
														_lowerCAmelCase  :							Tuple				     =					(1, 1024, model.config.vocab_size)
														self.assertEqual(output.shape,    __a)
														# change to expected output here
														_lowerCAmelCase  :							Any				     =					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],    __a,    atol=1E-3,    rtol=1E-3)





import datasets

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


_snake_case	=						"\\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"

_snake_case	=						"\\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"

_snake_case	=						"\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 						UpperCAmelCase_					( datasets.Metric):







							def      snake_case__   (     self):

														'''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      snake_case__   (     self,    __a,    __a,    __a=4,    __a=False):

														'''simple docstring'''

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