


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 :

   '''simple docstring'''







   a_				:							Any    = LEDConfig
   a_				:							str    = {}
   a_				:							List[str]    = "gelu"

   def __init__(  self  : List[Any]       ,  _lowerCamelCase  : Union[str, Any]       ,  _lowerCamelCase  : List[Any]=1_3       ,  _lowerCamelCase  : int=7       ,  _lowerCamelCase  : str=True       ,  _lowerCamelCase  : Any=False       ,  _lowerCamelCase  : str=9_9       ,  _lowerCamelCase  : str=3_2       ,  _lowerCamelCase  : Union[str, Any]=2       ,  _lowerCamelCase  : Optional[Any]=4       ,  _lowerCamelCase  : List[Any]=3_7       ,  _lowerCamelCase  : List[Any]=0.1       ,  _lowerCamelCase  : Tuple=0.1       ,  _lowerCamelCase  : Dict=2_0       ,  _lowerCamelCase  : str=2       ,  _lowerCamelCase  : Dict=1       ,  _lowerCamelCase  : Any=0       ,  _lowerCamelCase  : List[Any]=4       ,  ):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						parent
         __lowerCamelCase     :      List[str]       						=						batch_size
         __lowerCamelCase     :      str       						=						seq_length
         __lowerCamelCase     :      str       						=						is_training
         __lowerCamelCase     :      Any       						=						use_labels
         __lowerCamelCase     :      Any       						=						vocab_size
         __lowerCamelCase     :      List[str]       						=						hidden_size
         __lowerCamelCase     :      Optional[Any]       						=						num_hidden_layers
         __lowerCamelCase     :      Dict       						=						num_attention_heads
         __lowerCamelCase     :      Optional[Any]       						=						intermediate_size

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

   def   _snake_case    (  self  : int							):






         '''simple docstring'''



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

         __lowerCamelCase     :      Tuple       						=						ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size							)

         __lowerCamelCase     :      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       ,  )
         __lowerCamelCase     :      Dict       						=						prepare_led_inputs_dict(__a       ,  __a       ,  __a							)
         __lowerCamelCase     :      Union[str, Any]       						=						tf.concat(
             [tf.zeros_like(__a							)[:, :-1], tf.ones_like(__a							)[:, -1:]]       ,  axis=-1       ,  )
         __lowerCamelCase     :      Union[str, Any]       						=						global_attention_mask
         return config, inputs_dict


   def   _snake_case    (  self  : List[str]       ,  _lowerCamelCase  : List[Any]       ,  _lowerCamelCase  : int							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						TFLEDModel(config=__a							).get_decoder()
         __lowerCamelCase     :      Tuple       						=						inputs_dict["input_ids"]

         __lowerCamelCase     :      int       						=						input_ids[:1, :]
         __lowerCamelCase     :      List[str]       						=						inputs_dict["attention_mask"][:1, :]
         __lowerCamelCase     :      List[Any]       						=						1

         # first forward pass
         __lowerCamelCase     :      Any       						=						model(__a       ,  attention_mask=__a       ,  use_cache=__a							)

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

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

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

         __lowerCamelCase     :      Tuple       						=						model(__a       ,  attention_mask=__a							)[0]
         __lowerCamelCase     :      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     :      List[Any]       						=						int(ids_tensor((1,)       ,  output_from_past.shape[-1]							)							)
         __lowerCamelCase     :      List[str]       						=						output_from_no_past[:, -3:, random_slice_idx]
         __lowerCamelCase     :      Optional[int]       						=						output_from_past[:, :, random_slice_idx]

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





def   _UpperCAmelCase       (     UpperCAmelCase      :			List[Any]						,	UpperCAmelCase      :			Optional[int]						,	UpperCAmelCase      :			List[str]						,	UpperCAmelCase      :			Optional[int]=None						,	UpperCAmelCase      :			Optional[int]=None						,	UpperCAmelCase      :			Dict=None						,	UpperCAmelCase      :			Optional[int]=None						,	):
      """simple docstring"""




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

   '''simple docstring'''







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

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						TFLEDModelTester(self							)
         __lowerCamelCase     :      Any       						=						ConfigTester(self       ,  config_class=__a							)

   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         self.config_tester.run_common_tests()

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.check_decoder_model_past_large_inputs(*__a							)

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						self.model_tester.prepare_config_and_inputs_for_common()
         __lowerCamelCase     :      Optional[int]       						=						tf.zeros_like(inputs_dict["""attention_mask"""]							)
         __lowerCamelCase     :      Union[str, Any]       						=						2
         __lowerCamelCase     :      str       						=						tf.where(
             tf.range(self.model_tester.seq_length							)[None, :] < num_global_attn_indices       ,  1       ,  inputs_dict["""global_attention_mask"""]       ,  )

         __lowerCamelCase     :      Dict       						=						True
         __lowerCamelCase     :      str       						=						self.model_tester.seq_length
         __lowerCamelCase     :      Union[str, Any]       						=						self.model_tester.encoder_seq_length

         def check_decoder_attentions_output(_lowerCamelCase  : Optional[int]							):
               __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(_lowerCamelCase  : Optional[Any]							):
               __lowerCamelCase     :      Union[str, Any]       						=						[t.numpy() for t in outputs.encoder_attentions]
               __lowerCamelCase     :      List[Any]       						=						[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     :      Dict       						=						True
               __lowerCamelCase     :      Optional[Any]       						=						False
               __lowerCamelCase     :      int       						=						False
               __lowerCamelCase     :      Optional[int]       						=						model_class(__a							)
               __lowerCamelCase     :      int       						=						model(self._prepare_for_class(__a       ,  __a							)							)
               __lowerCamelCase     :      Any       						=						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     :      List[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     :      int       						=						True
               __lowerCamelCase     :      Tuple       						=						model_class(__a							)
               __lowerCamelCase     :      str       						=						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     :      Any       						=						True
               __lowerCamelCase     :      List[str]       						=						True
               __lowerCamelCase     :      Tuple       						=						model_class(__a							)
               __lowerCamelCase     :      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  : str							):






         '''simple docstring'''



         pass


   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         pass





def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[int]      ):
      """simple docstring"""




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


__UpperCamelCase    :						List[Any]     =							1E-4






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

   '''simple docstring'''







   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""							).led

         # change to intended input here
         __lowerCamelCase     :      int       						=						_long_tensor([5_1_2 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]							)
         __lowerCamelCase     :      Tuple       						=						_long_tensor([1_2_8 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]							)
         __lowerCamelCase     :      Optional[Any]       						=						prepare_led_inputs_dict(model.config       ,  __a       ,  __a							)
         __lowerCamelCase     :      Optional[int]       						=						model(**__a							)[0]
         __lowerCamelCase     :      Optional[int]       						=						(1, 1_0_2_4, 7_6_8)
         self.assertEqual(output.shape       ,  __a							)
         # change to expected output here
         __lowerCamelCase     :      Tuple       						=						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  : Dict							):






         '''simple docstring'''



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

         # change to intended input here
         __lowerCamelCase     :      Optional[int]       						=						_long_tensor([5_1_2 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]							)
         __lowerCamelCase     :      List[str]       						=						_long_tensor([1_2_8 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]							)
         __lowerCamelCase     :      Optional[Any]       						=						prepare_led_inputs_dict(model.config       ,  __a       ,  __a							)
         __lowerCamelCase     :      Union[str, Any]       						=						model(**__a							)[0]
         __lowerCamelCase     :      int       						=						(1, 1_0_2_4, model.config.vocab_size)
         self.assertEqual(output.shape       ,  __a							)
         # change to expected output here
         __lowerCamelCase     :      Optional[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]       ,  __a       ,  atol=1E-3       ,  rtol=1E-3							)







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCamelCase    :						Optional[Any]     =							{
    'configuration_swinv2': ['SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Swinv2Config'],
}


try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						List[Any]     =							[
        'SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST',
        'Swinv2ForImageClassification',
        'Swinv2ForMaskedImageModeling',
        'Swinv2Model',
        'Swinv2PreTrainedModel',
    ]


if TYPE_CHECKING:
    from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_swinva import (
            SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
            SwinvaForImageClassification,
            SwinvaForMaskedImageModeling,
            SwinvaModel,
            SwinvaPreTrainedModel,
        )


else:
    import sys

    __UpperCamelCase    :						List[Any]     =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



