






'''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     a_						:
     lowercase							=				LEDConfig
     lowercase							=				{}
     lowercase							=				"gelu"

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



           """simple docstring"""






           UpperCamelCase      = parent
           UpperCamelCase      = batch_size
           UpperCamelCase      = seq_length
           UpperCamelCase      = is_training
           UpperCamelCase      = use_labels
           UpperCamelCase      = vocab_size
           UpperCamelCase      = hidden_size
           UpperCamelCase      = num_hidden_layers
           UpperCamelCase      = num_attention_heads
           UpperCamelCase      = intermediate_size

           UpperCamelCase      = hidden_dropout_prob
           UpperCamelCase      = attention_probs_dropout_prob
           UpperCamelCase      = max_position_embeddings
           UpperCamelCase      = eos_token_id
           UpperCamelCase      = pad_token_id
           UpperCamelCase      = bos_token_id
           UpperCamelCase      = 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
           UpperCamelCase      = 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
           UpperCamelCase      = (
               self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
           )

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



           """simple docstring"""






           UpperCamelCase      = ids_tensor([self.batch_size, self.seq_length - 1]      ,		self.vocab_size				)
           UpperCamelCase      = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size				)      ,		1				)
           UpperCamelCase      = tf.concat([input_ids, eos_tensor]      ,		axis=1				)

           UpperCamelCase      = ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size				)

           UpperCamelCase      = 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      ,		)
           UpperCamelCase      = prepare_led_inputs_dict(__A      ,		__A      ,		__A				)
           UpperCamelCase      = tf.concat(
               [tf.zeros_like(__A				)[:, :-1], tf.ones_like(__A				)[:, -1:]]      ,		axis=-1      ,		)
           UpperCamelCase      = global_attention_mask
           return config, inputs_dict


     def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				str:



           """simple docstring"""






           UpperCamelCase      = TFLEDModel(config=__A				).get_decoder()
           UpperCamelCase      = inputs_dict["""input_ids"""]

           UpperCamelCase      = input_ids[:1, :]
           UpperCamelCase      = inputs_dict["""attention_mask"""][:1, :]
           UpperCamelCase      = 1

           # first forward pass
           UpperCamelCase      = model(__A      ,		attention_mask=__A      ,		use_cache=__A				)

           UpperCamelCase      = outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           UpperCamelCase      = ids_tensor((self.batch_size, 3)      ,		config.vocab_size				)
           UpperCamelCase      = tf.cast(ids_tensor((self.batch_size, 3)      ,		2				)      ,		tf.inta				)

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

           UpperCamelCase      = model(__A      ,		attention_mask=__A				)[0]
           UpperCamelCase      = 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
           UpperCamelCase      = int(ids_tensor((1,)      ,		output_from_past.shape[-1]				)				)
           UpperCamelCase      = output_from_no_past[:, -3:, random_slice_idx]
           UpperCamelCase      = output_from_past[:, :, random_slice_idx]

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







def    lowercase__			(				__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase=None		,						__UpperCamelCase=None		,						__UpperCamelCase=None		,						__UpperCamelCase=None		,						)->			Optional[Any]:





      if attention_mask is None:
            UpperCamelCase      = tf.cast(tf.math.not_equal(lowercase__		,						config.pad_token_id   )		,						tf.inta   )
      if decoder_attention_mask is None:
            UpperCamelCase      = 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:
            UpperCamelCase      = tf.ones((config.encoder_layers, config.encoder_attention_heads)   )
      if decoder_head_mask is None:
            UpperCamelCase      = 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     a_						(      A__     ,	A__     ,	unittest.TestCase    ):
     lowercase							=				(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
     lowercase							=				(TFLEDForConditionalGeneration,) if is_tf_available() else ()
     lowercase							=				(
         {
             "conversational": TFLEDForConditionalGeneration,
             "feature-extraction": TFLEDModel,
             "summarization": TFLEDForConditionalGeneration,
             "text2text-generation": TFLEDForConditionalGeneration,
             "translation": TFLEDForConditionalGeneration,
         }
         if is_tf_available()
         else {}
     )
     lowercase							=				True
     lowercase							=				False
     lowercase							=				False
     lowercase							=				False

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



           """simple docstring"""






           UpperCamelCase      = TFLEDModelTester(self				)
           UpperCamelCase      = ConfigTester(self      ,		config_class=__A				)

     def   A__						(				self				)  ->				str:



           """simple docstring"""






           self.config_tester.run_common_tests()

     def   A__						(				self				)  ->				str:



           """simple docstring"""






           UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_decoder_model_past_large_inputs(*__A				)

     def   A__						(				self				)  ->				Dict:



           """simple docstring"""






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

           UpperCamelCase      = True
           UpperCamelCase      = self.model_tester.seq_length
           UpperCamelCase      = self.model_tester.encoder_seq_length

           def check_decoder_attentions_output(_SCREAMING_SNAKE_CASE				):
                 UpperCamelCase      = 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(_SCREAMING_SNAKE_CASE				):
                 UpperCamelCase      = [t.numpy() for t in outputs.encoder_attentions]
                 UpperCamelCase      = [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:
                 UpperCamelCase      = True
                 UpperCamelCase      = False
                 UpperCamelCase      = False
                 UpperCamelCase      = model_class(__A				)
                 UpperCamelCase      = model(self._prepare_for_class(__A      ,		__A				)				)
                 UpperCamelCase      = len(__A				)
                 self.assertEqual(config.output_hidden_states      ,		__A				)
                 check_encoder_attentions_output(__A				)

                 if self.is_encoder_decoder:
                       UpperCamelCase      = model_class(__A				)
                       UpperCamelCase      = 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"]
                 UpperCamelCase      = True
                 UpperCamelCase      = model_class(__A				)
                 UpperCamelCase      = 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
                 UpperCamelCase      = True
                 UpperCamelCase      = True
                 UpperCamelCase      = model_class(__A				)
                 UpperCamelCase      = 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   A__						(				self				)  ->				str:



           """simple docstring"""






           pass


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



           """simple docstring"""






           pass







def    lowercase__			(				__UpperCamelCase   )->			int:
      return tf.constant(lowercase__		,						dtype=tf.intaa   )


SCREAMING_SNAKE_CASE__     =       1E-4






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

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



           """simple docstring"""






           UpperCamelCase      = TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""				).led

           # change to intended input here
           UpperCamelCase      = _long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
           UpperCamelCase      = _long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
           UpperCamelCase      = prepare_led_inputs_dict(model.config      ,		__A      ,		__A				)
           UpperCamelCase      = model(**__A				)[0]
           UpperCamelCase      = (1, 1024, 768)
           self.assertEqual(output.shape      ,		__A				)
           # change to expected output here
           UpperCamelCase      = tf.convert_to_tensor(
               [[2.3_0_5_0, 2.8_2_7_9, 0.6_5_3_1], [-1.8_4_5_7, -0.1_4_5_5, -3.5_6_6_1], [-1.0_1_8_6, 0.4_5_8_6, -2.2_0_4_3]]      ,		)
           tf.debugging.assert_near(output[:, :3, :3]      ,		__A      ,		atol=1e-3				)


     def   A__						(				self				)  ->				Dict:



           """simple docstring"""






           UpperCamelCase      = TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""				)

           # change to intended input here
           UpperCamelCase      = _long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
           UpperCamelCase      = _long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
           UpperCamelCase      = prepare_led_inputs_dict(model.config      ,		__A      ,		__A				)
           UpperCamelCase      = model(**__A				)[0]
           UpperCamelCase      = (1, 1024, model.config.vocab_size)
           self.assertEqual(output.shape      ,		__A				)
           # change to expected output here
           UpperCamelCase      = tf.convert_to_tensor(
               [[33.6507, 6.4_5_7_2, 16.8089], [5.8_7_3_9, -2.4_2_3_8, 11.2902], [-3.2_1_3_9, -4.3_1_4_9, 4.2_7_8_3]]      ,		)
           tf.debugging.assert_near(output[:, :3, :3]      ,		__A      ,		atol=1e-3      ,		rtol=1e-3				)








'''simple docstring'''

import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)






class     a_						(      unittest.TestCase    ):

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = ["""a""", """b""", """c"""]

        # Defaults to last layer if both are None
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[2]				)

        # Out indices set to match out features
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(["""a""", """c"""]      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[0, 2]				)

        # Out features set to match out indices
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		[0, 2]      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[0, 2]				)

        # Out features selected from negative indices
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		[-3, -1]      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[-3, -1]				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 1)      ,		_SCREAMING_SNAKE_CASE				)

        # Out features must be a list
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(("""a""", """b""")      ,		(0, 1)      ,		["""a""", """b"""]				)

        # Out features must be a subset of stage names
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 1)      ,		["""a"""]				)

        # Out indices must be a list or tuple
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,		0      ,		["""a""", """b"""]				)

        # Out indices must be a subset of stage names
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,		(0, 1)      ,		["""a"""]				)

        # Out features and out indices must be the same length
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0,)      ,		["""a""", """b""", """c"""]				)

        # Out features should match out indices
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 2)      ,		["""a""", """b""", """c"""]				)

        # Out features and out indices should be in order
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""b""", """a"""]      ,		(0, 1)      ,		["""a""", """b"""]				)

        # Check passes with valid inputs
        verify_out_features_out_indices(["""a""", """b""", """d"""]      ,		(0, 1, -1)      ,		["""a""", """b""", """c""", """d"""]				)


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



        """simple docstring"""






        UpperCamelCase      = BackboneMixin()

        UpperCamelCase      = ["""a""", """b""", """c"""]
        UpperCamelCase      = ["""a""", """c"""]
        UpperCamelCase      = [0, 2]

        # Check that the output features and indices are set correctly
        self.assertEqual(backbone.out_features      ,		["""a""", """c"""]				)
        self.assertEqual(backbone.out_indices      ,		[0, 2]				)

        # Check out features and indices are updated correctly
        UpperCamelCase      = ["""a""", """b"""]
        self.assertEqual(backbone.out_features      ,		["""a""", """b"""]				)
        self.assertEqual(backbone.out_indices      ,		[0, 1]				)

        UpperCamelCase      = [-3, -1]
        self.assertEqual(backbone.out_features      ,		["""a""", """c"""]				)
        self.assertEqual(backbone.out_indices      ,		[-3, -1]				)
