


'''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    :


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       LEDConfig
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       {}
     SCREAMING_SNAKE_CASE	:			Dict							       =       "gelu"

     def __init__(    self					:		List[Any]							,			snake_case					:		Optional[Any]							,			snake_case					:		List[Any]=13							,			snake_case					:		Dict=7							,			snake_case					:		Dict=True							,			snake_case					:		int=False							,			snake_case					:		Optional[Any]=99							,			snake_case					:		List[Any]=32							,			snake_case					:		List[Any]=2							,			snake_case					:		Optional[int]=4							,			snake_case					:		Optional[int]=37							,			snake_case					:		str=0.1							,			snake_case					:		Union[str, Any]=0.1							,			snake_case					:		List[str]=20							,			snake_case					:		int=2							,			snake_case					:		Optional[Any]=1							,			snake_case					:		Tuple=0							,			snake_case					:		Any=4							,			)						->							Dict:
          __UpperCAmelCase     :			List[Any]  							=      parent
          __UpperCAmelCase     :			Tuple  							=      batch_size
          __UpperCAmelCase     :			List[Any]  							=      seq_length
          __UpperCAmelCase     :			List[Any]  							=      is_training
          __UpperCAmelCase     :			str  							=      use_labels
          __UpperCAmelCase     :			List[str]  							=      vocab_size
          __UpperCAmelCase     :			Union[str, Any]  							=      hidden_size
          __UpperCAmelCase     :			List[str]  							=      num_hidden_layers
          __UpperCAmelCase     :			List[Any]  							=      num_attention_heads
          __UpperCAmelCase     :			Optional[Any]  							=      intermediate_size

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

     def 			lowerCamelCase__			(    self					:		Optional[Any]      )						->							Dict:
          __UpperCAmelCase     :			List[str]  							=      ids_tensor([self.batch_size, self.seq_length - 1]							,			self.vocab_size      )
          __UpperCAmelCase     :			Any  							=      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size      )							,			1      )
          __UpperCAmelCase     :			Union[str, Any]  							=      tf.concat([input_ids, eos_tensor]							,			axis=1      )

          __UpperCAmelCase     :			int  							=      ids_tensor([self.batch_size, self.seq_length]							,			self.vocab_size      )

          __UpperCAmelCase     :			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							,			)
          __UpperCAmelCase     :			Dict  							=      prepare_led_inputs_dict(_lowerCamelCase							,			_lowerCamelCase							,			_lowerCamelCase      )
          __UpperCAmelCase     :			Optional[Any]  							=      tf.concat(
              [tf.zeros_like(_lowerCamelCase      )[:, :-1], tf.ones_like(_lowerCamelCase      )[:, -1:]]							,			axis=-1							,			)
          __UpperCAmelCase     :			Optional[int]  							=      global_attention_mask
          return config, inputs_dict






     def 			lowerCamelCase__			(    self					:		Optional[Any]							,			snake_case					:		str							,			snake_case					:		Optional[int]      )						->							int:
          __UpperCAmelCase     :			Optional[int]  							=      TFLEDModel(config=_lowerCamelCase      ).get_decoder()
          __UpperCAmelCase     :			str  							=      inputs_dict['''input_ids''']

          __UpperCAmelCase     :			Optional[Any]  							=      input_ids[:1, :]
          __UpperCAmelCase     :			Optional[Any]  							=      inputs_dict['''attention_mask'''][:1, :]
          __UpperCAmelCase     :			List[Any]  							=      1

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

          __UpperCAmelCase     :			List[str]  							=      outputs.to_tuple()

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

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

          __UpperCAmelCase     :			Optional[int]  							=      model(_lowerCamelCase							,			attention_mask=_lowerCamelCase      )[0]
          __UpperCAmelCase     :			Dict  							=      model(_lowerCamelCase							,			attention_mask=_lowerCamelCase							,			past_key_values=_lowerCamelCase      )[0]

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

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

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




def      _a     (						_lowercase :     Optional[Any]      , _lowercase :     Dict      , _lowercase :     Tuple      , _lowercase :     int=None      , _lowercase :     int=None      , _lowercase :     List[Any]=None      , _lowercase :     Dict=None      , ):





     '''simple docstring'''






     if attention_mask is None:
          __UpperCAmelCase     :			List[str]  							=      tf.cast(tf.math.not_equal(lowerCamelCase__      , config.pad_token_id  )      , tf.inta  )
     if decoder_attention_mask is None:
          __UpperCAmelCase     :			List[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:
          __UpperCAmelCase     :			Union[str, Any]  							=      tf.ones((config.encoder_layers, config.encoder_attention_heads)  )
     if decoder_head_mask is None:
          __UpperCAmelCase     :			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      a    (		a__     ,  a__     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			str							       =       (TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
     SCREAMING_SNAKE_CASE	:			List[str]							       =       (TFLEDForConditionalGeneration,) if is_tf_available() else ()
     SCREAMING_SNAKE_CASE	:			str							       =       (
         {
             "conversational": TFLEDForConditionalGeneration,
             "feature-extraction": TFLEDModel,
             "summarization": TFLEDForConditionalGeneration,
             "text2text-generation": TFLEDForConditionalGeneration,
             "translation": TFLEDForConditionalGeneration,
         }
         if is_tf_available()
         else {}
     )
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       True
     SCREAMING_SNAKE_CASE	:			List[str]							       =       False
     SCREAMING_SNAKE_CASE	:			int							       =       False
     SCREAMING_SNAKE_CASE	:			str							       =       False

     def 			lowerCamelCase__			(    self					:		List[Any]      )						->							List[Any]:
          __UpperCAmelCase     :			Tuple  							=      TFLEDModelTester(self      )
          __UpperCAmelCase     :			Tuple  							=      ConfigTester(self							,			config_class=_lowerCamelCase      )

     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Dict:
          self.config_tester.run_common_tests()

     def 			lowerCamelCase__			(    self					:		Any      )						->							Any:
          __UpperCAmelCase     :			List[str]  							=      self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.check_decoder_model_past_large_inputs(*_lowerCamelCase      )

     def 			lowerCamelCase__			(    self					:		int      )						->							int:
          __UpperCAmelCase     :			List[str]  							=      self.model_tester.prepare_config_and_inputs_for_common()
          __UpperCAmelCase     :			str  							=      tf.zeros_like(inputs_dict['''attention_mask''']      )
          __UpperCAmelCase     :			str  							=      2
          __UpperCAmelCase     :			Dict  							=      tf.where(
              tf.range(self.model_tester.seq_length      )[None, :] < num_global_attn_indices							,			1							,			inputs_dict['''global_attention_mask''']							,			)

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

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

               if self.is_encoder_decoder:
                    __UpperCAmelCase     :			str  							=      model_class(_lowerCamelCase      )
                    __UpperCAmelCase     :			Dict  							=      model(self._prepare_for_class(_lowerCamelCase							,			_lowerCamelCase      )      )
                    self.assertEqual(config.output_hidden_states							,			_lowerCamelCase      )
                    check_decoder_attentions_output(_lowerCamelCase      )

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

               # Check attention is always last and order is fine
               __UpperCAmelCase     :			Tuple  							=      True
               __UpperCAmelCase     :			Dict  							=      True
               __UpperCAmelCase     :			Union[str, Any]  							=      model_class(_lowerCamelCase      )
               __UpperCAmelCase     :			List[str]  							=      model(self._prepare_for_class(_lowerCamelCase							,			_lowerCamelCase      )      )

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

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






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							Optional[int]:
          pass




def      _a     (						_lowercase :     List[str]  ):





     '''simple docstring'''






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


__UpperCAmelCase      :Optional[Any]			    =       1e-4



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


     """simple docstring"""






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							Optional[Any]:
          __UpperCAmelCase     :			List[Any]  							=      TFLEDForConditionalGeneration.from_pretrained('''allenai/led-base-16384'''      ).led

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






     def 			lowerCamelCase__			(    self					:		Tuple      )						->							int:
          __UpperCAmelCase     :			Tuple  							=      TFLEDForConditionalGeneration.from_pretrained('''allenai/led-base-16384'''      )

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



'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase      :List[Any]			    =       {
    "configuration_lxmert": ["LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "LxmertConfig"],
    "tokenization_lxmert": ["LxmertTokenizer"],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase      :List[Any]			    =       ["LxmertTokenizerFast"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase      :List[Any]			    =       [
          "LxmertEncoder",
          "LxmertForPreTraining",
          "LxmertForQuestionAnswering",
          "LxmertModel",
          "LxmertPreTrainedModel",
          "LxmertVisualFeatureEncoder",
          "LxmertXLayer",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase      :List[str]			    =       [
          "TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFLxmertForPreTraining",
          "TFLxmertMainLayer",
          "TFLxmertModel",
          "TFLxmertPreTrainedModel",
          "TFLxmertVisualFeatureEncoder",
      ]


if TYPE_CHECKING:
      from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig
      from .tokenization_lxmert import LxmertTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_lxmert_fast import LxmertTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_lxmert import (
                LxmertEncoder,
                LxmertForPreTraining,
                LxmertForQuestionAnswering,
                LxmertModel,
                LxmertPreTrainedModel,
                LxmertVisualFeatureEncoder,
                LxmertXLayer,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_lxmert import (
                TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFLxmertForPreTraining,
                TFLxmertMainLayer,
                TFLxmertModel,
                TFLxmertPreTrainedModel,
                TFLxmertVisualFeatureEncoder,
            )

else:
      import sys

      __UpperCAmelCase      :int			    =       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)