





from __future__ import annotations

import unittest

import numpy as np

from transformers import OPTConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, 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 GPTaTokenizer, TFOPTForCausalLM, TFOPTModel


def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			Any					,	UpperCamelCase__     :			Any=None					,	UpperCamelCase__     :			Dict=None    )->str:
       if attention_mask is None:
              A__		   =		tf.cast(tf.math.not_equal(UpperCamelCase__					,	config.pad_token_id    )					,	tf.inta    )
       return {"input_ids": input_ids, "attention_mask": attention_mask}




@require_tf
class        SCREAMING_SNAKE_CASE__					:
 __SCREAMING_SNAKE_CASE							=      OPTConfig
 __SCREAMING_SNAKE_CASE							=      {}
 __SCREAMING_SNAKE_CASE							=      '''gelu'''



 def __init__(				self,__lowerCamelCase,__lowerCamelCase=13,__lowerCamelCase=7,__lowerCamelCase=True,__lowerCamelCase=False,__lowerCamelCase=99,__lowerCamelCase=16,__lowerCamelCase=2,__lowerCamelCase=4,__lowerCamelCase=4,__lowerCamelCase="gelu",__lowerCamelCase=0.1,__lowerCamelCase=0.1,__lowerCamelCase=20,__lowerCamelCase=2,__lowerCamelCase=1,__lowerCamelCase=0,__lowerCamelCase=16,__lowerCamelCase=16,):
        A__		   =		parent
        A__		   =		batch_size
        A__		   =		seq_length
        A__		   =		is_training
        A__		   =		use_labels
        A__		   =		vocab_size
        A__		   =		hidden_size
        A__		   =		num_hidden_layers
        A__		   =		num_attention_heads
        A__		   =		intermediate_size
        A__		   =		hidden_act
        A__		   =		hidden_dropout_prob
        A__		   =		attention_probs_dropout_prob
        A__		   =		max_position_embeddings
        A__		   =		eos_token_id
        A__		   =		pad_token_id
        A__		   =		bos_token_id
        A__		   =		embed_dim
        A__		   =		word_embed_proj_dim
        A__		   =		False



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

        A__		   =		self.config_cls(
            vocab_size=self.vocab_size,hidden_size=self.hidden_size,num_hidden_layers=self.num_hidden_layers,num_attention_heads=self.num_attention_heads,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_id=self.eos_token_id,bos_token_id=self.bos_token_id,pad_token_id=self.pad_token_id,embed_dim=self.embed_dim,word_embed_proj_dim=self.word_embed_proj_dim,is_encoder_decoder=__lowerCamelCase,**self.config_updates,)
        A__		   =		prepare_opt_inputs_dict(__lowerCamelCase,__lowerCamelCase					)
        return config, inputs_dict




 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase					):
        A__		   =		TFOPTModel(config=__lowerCamelCase					)
        A__		   =		inputs_dict['''input_ids''']

        A__		   =		input_ids[:1, :]
        A__		   =		inputs_dict['''attention_mask'''][:1, :]
        A__		   =		1

        # first forward pass
        A__		   =		model(__lowerCamelCase,attention_mask=__lowerCamelCase,use_cache=__lowerCamelCase					)

        A__   ,      A__		   =		outputs.to_tuple()

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

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

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

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




@require_tf
class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__							,   UpperCamelCase__							,   unittest.TestCase ):
 __SCREAMING_SNAKE_CASE							=      (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
 __SCREAMING_SNAKE_CASE							=      (TFOPTForCausalLM,) if is_tf_available() else ()
 __SCREAMING_SNAKE_CASE							=      (
     {'''feature-extraction''': TFOPTModel, '''text-generation''': TFOPTForCausalLM} if is_tf_available() else {}
 )
 __SCREAMING_SNAKE_CASE							=      False
 __SCREAMING_SNAKE_CASE							=      False
 __SCREAMING_SNAKE_CASE							=      False
 __SCREAMING_SNAKE_CASE							=      10



 def 							UpperCamelCase     (				self					):
        A__		   =		TFOPTModelTester(self					)
        A__		   =		ConfigTester(self,config_class=__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        self.config_tester.run_common_tests()



 def 							UpperCamelCase     (				self					):
        A__		   =		self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase					)




 def 							UpperCamelCase     (				self					):
        A__   ,      A__		   =		self.model_tester.prepare_config_and_inputs_for_common()

        def _get_word_embedding_weight(__lowerCamelCase,__lowerCamelCase					):
               if hasattr(__lowerCamelCase,'''weight'''					):
                      return embedding_layer.weight
               else:
                      # Here we build the word embeddings weights if not exists.
                      # And then we retry to get the attribute once built.
                      model.build()
                      if hasattr(__lowerCamelCase,'''weight'''					):
                             return embedding_layer.weight
                      else:
                             return None

        for model_class in self.all_model_classes:
               for size in [config.vocab_size - 10, config.vocab_size + 10]:
                      # build the embeddings
                      A__		   =		model_class(config=__lowerCamelCase					)
                      A__		   =		_get_word_embedding_weight(__lowerCamelCase,model.get_input_embeddings()					)
                      A__		   =		_get_word_embedding_weight(__lowerCamelCase,model.get_output_embeddings()					)

                      # reshape the embeddings
                      model.resize_token_embeddings(__lowerCamelCase					)
                      A__		   =		_get_word_embedding_weight(__lowerCamelCase,model.get_input_embeddings()					)
                      A__		   =		_get_word_embedding_weight(__lowerCamelCase,model.get_output_embeddings()					)

                      # check that the resized embeddings size matches the desired size.
                      A__		   =		size if size is not None else config.vocab_size

                      self.assertEqual(new_input_embeddings.shape[0],__lowerCamelCase					)

                      # check that weights remain the same after resizing
                      A__		   =		True
                      for pa, pa in zip(old_input_embeddings.value(),new_input_embeddings.value()					):
                             if tf.math.reduce_sum(tf.math.abs(pa - pa					)					) > 0:
                                    A__		   =		False
                      self.assertTrue(__lowerCamelCase					)

                      if old_output_embeddings is not None and new_output_embeddings is not None:
                             self.assertEqual(new_output_embeddings.shape[0],__lowerCamelCase					)

                             A__		   =		True
                             for pa, pa in zip(old_output_embeddings.value(),new_output_embeddings.value()					):
                                    if tf.math.reduce_sum(tf.math.abs(pa - pa					)					) > 0:
                                           A__		   =		False
                             self.assertTrue(__lowerCamelCase					)


def       UpperCamelCase__(			UpperCamelCase__     :			Any    )->Union[str, Any]:
       return tf.constant(UpperCamelCase__					,	dtype=tf.intaa    )




@require_tf
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):
 __SCREAMING_SNAKE_CASE							=      99



 def 							UpperCamelCase     (				self					):
        A__		   =		tf.ones((4, 1),dtype=tf.intaa					) * 2
        A__		   =		tf.concat([ids_tensor((4, 6),self.vocab_size - 3					) + 3, eos_column_vector],axis=1					)
        A__		   =		input_ids.shape[0]
        A__		   =		OPTConfig(
            vocab_size=self.vocab_size,hidden_size=24,num_hidden_layers=2,num_attention_heads=2,ffn_dim=32,max_position_embeddings=48,eos_token_id=2,pad_token_id=1,bos_token_id=0,)
        return config, input_ids, batch_size




@require_sentencepiece
@require_tf
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 @slow
 def 							UpperCamelCase     (				self					):
        A__		   =		TFOPTModel.from_pretrained('''facebook/opt-350m'''					)
        A__		   =		_long_tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]					)
        A__		   =		tf.not_equal(__lowerCamelCase,model.config.pad_token_id					)
        with tf.GradientTape():
               A__		   =		model(input_ids=__lowerCamelCase,attention_mask=__lowerCamelCase					).last_hidden_state
        A__		   =		(1, 11, 512)
        self.assertEqual(output.shape,__lowerCamelCase					)
        A__		   =		tf.constant(
            [[-0.2873, -1.9218, -0.3033], [-1.2710, -0.1338, -0.1902], [0.4095, 0.1214, -1.3121]]					)
        self.assertTrue(np.allclose(output[:, :3, :3],__lowerCamelCase,atol=4E-3					)					)

        A__		   =		tf.function(__lowerCamelCase,jit_compile=__lowerCamelCase					)
        A__		   =		xla_generate(__lowerCamelCase,__lowerCamelCase					)[0]
        self.assertTrue(np.allclose(output[:, :3, :3],__lowerCamelCase,atol=4E-2					)					)




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



 def 							UpperCamelCase     (				self					):
        super().setUp()
        A__		   =		'''facebook/opt-350m'''




 def 							UpperCamelCase     (				self					):
        A__		   =		TFOPTForCausalLM.from_pretrained(self.path_model					)
        A__		   =		GPTaTokenizer.from_pretrained(self.path_model					)

        A__		   =		[
            '''Today is a beautiful day and I want to''',
            '''In the city of''',
            '''Paris is the capital of France and''',
            '''Computers and mobile phones have taken''',
        ]
        # verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False
        A__		   =		tokenizer(__lowerCamelCase,return_tensors='''tf''',padding=__lowerCamelCase,add_special_tokens=__lowerCamelCase					)
        A__		   =		tf.math.reduce_mean(model(inputs.input_ids,attention_mask=inputs.attention_mask					)[0],axis=-1					)
        A__		   =		tf.constant(
            [
                [1.3851, -13.8923, -10.5229, -10.7533, -0.2309, -10.2384, -0.5365, -9.0947, -5.1670],
                [-4.7073, -10.6276, -3.9415, -21.5242, -0.2822, -0.2822, -0.2822, -0.2822, -0.2822],
                [0.6247, -3.4229, -8.9179, -1.4297, -14.1650, 1.4146, -9.0218, -0.2703, -0.2703],
                [6.4783, -1.9913, -10.7926, -2.3336, 1.5092, -0.9974, -6.8213, 1.3477, 1.3477],
            ]					)
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase,atol=1E-4					)					)

        A__		   =		tf.function(__lowerCamelCase,jit_compile=__lowerCamelCase					)
        A__		   =		tf.math.reduce_mean(xla_generate(inputs.input_ids,attention_mask=inputs.attention_mask					)[0],axis=-1					)
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase,atol=1E-4					)					)




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



 @property
 def 							UpperCamelCase     (				self					):
        return [
            "Today is a beautiful day and I want",
            "In the city of",
            "Paris is the capital of France and",
            "Computers and mobile phones have taken",
        ]



 def 							UpperCamelCase     (				self					):
        A__		   =		'''facebook/opt-125m'''

        A__		   =		[
            '''Today is a beautiful day and I want to''',
            '''In the city of New York, the city''',
            '''Paris is the capital of France and the capital''',
            '''Computers and mobile phones have taken over the''',
        ]

        A__		   =		[]
        A__		   =		GPTaTokenizer.from_pretrained(__lowerCamelCase					)
        A__		   =		TFOPTForCausalLM.from_pretrained(__lowerCamelCase					)

        for prompt in self.prompts:
               A__		   =		tokenizer(__lowerCamelCase,return_tensors='''tf'''					).input_ids

               A__		   =		model.generate(__lowerCamelCase,max_length=10					)

               A__		   =		tokenizer.batch_decode(__lowerCamelCase,skip_special_tokens=__lowerCamelCase					)
               predicted_outputs += generated_string

        self.assertListEqual(__lowerCamelCase,__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        A__		   =		'''facebook/opt-350m'''

        A__		   =		GPTaTokenizer.from_pretrained(__lowerCamelCase					)
        A__		   =		TFOPTForCausalLM.from_pretrained(__lowerCamelCase					)

        A__		   =		'''left'''

        # use different length sentences to test batching
        A__		   =		[
            '''Hello, my dog is a little''',
            '''Today, I''',
        ]

        A__		   =		tokenizer(__lowerCamelCase,return_tensors='''tf''',padding=__lowerCamelCase					)
        A__		   =		inputs['''input_ids''']

        A__		   =		model.generate(input_ids=__lowerCamelCase,attention_mask=inputs['''attention_mask''']					)

        A__		   =		tokenizer(sentences[0],return_tensors='''tf'''					).input_ids
        A__		   =		model.generate(input_ids=__lowerCamelCase					)

        A__		   =		inputs_non_padded.shape[-1] - tf.math.reduce_sum(
            tf.cast(inputs['''attention_mask'''][-1],tf.intaa					)					)
        A__		   =		tokenizer(sentences[1],return_tensors='''tf'''					).input_ids
        A__		   =		model.generate(input_ids=__lowerCamelCase,max_length=model.config.max_length - num_paddings					)

        A__		   =		tokenizer.batch_decode(__lowerCamelCase,skip_special_tokens=__lowerCamelCase					)
        A__		   =		tokenizer.decode(output_non_padded[0],skip_special_tokens=__lowerCamelCase					)
        A__		   =		tokenizer.decode(output_padded[0],skip_special_tokens=__lowerCamelCase					)

        A__		   =		[
            '''Hello, my dog is a little bit of a dork.\nI\'m a little bit''',
            '''Today, I was in the middle of a conversation with a friend about the''',
        ]
        self.assertListEqual(__lowerCamelCase,__lowerCamelCase					)
        self.assertListEqual(__lowerCamelCase,[non_padded_sentence, padded_sentence]					)




 def 							UpperCamelCase     (				self					):
        A__		   =		'''facebook/opt-350m'''

        A__		   =		[
            '''Today is a beautiful day and I want to''',
            '''In the city of San Francisco, the city''',
            '''Paris is the capital of France and the capital''',
            '''Computers and mobile phones have taken over the''',
        ]

        A__		   =		[]
        A__		   =		GPTaTokenizer.from_pretrained(__lowerCamelCase					)
        A__		   =		TFOPTForCausalLM.from_pretrained(__lowerCamelCase					)

        for prompt in self.prompts:
               A__		   =		tokenizer(__lowerCamelCase,return_tensors='''tf'''					).input_ids

               A__		   =		model.generate(__lowerCamelCase,max_length=10					)

               A__		   =		tokenizer.batch_decode(__lowerCamelCase,skip_special_tokens=__lowerCamelCase					)
               predicted_outputs += generated_string

        self.assertListEqual(__lowerCamelCase,__lowerCamelCase					)












from typing import TYPE_CHECKING

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


a__: str							   =						{
    'configuration_mega': ['MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegaConfig', 'MegaOnnxConfig'],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a__: Union[str, Any]							   =						[
           'MEGA_PRETRAINED_MODEL_ARCHIVE_LIST',
           'MegaForCausalLM',
           'MegaForMaskedLM',
           'MegaForMultipleChoice',
           'MegaForQuestionAnswering',
           'MegaForSequenceClassification',
           'MegaForTokenClassification',
           'MegaModel',
           'MegaPreTrainedModel',
       ]

if TYPE_CHECKING:
       from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mega import (
                  MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  MegaForCausalLM,
                  MegaForMaskedLM,
                  MegaForMultipleChoice,
                  MegaForQuestionAnswering,
                  MegaForSequenceClassification,
                  MegaForTokenClassification,
                  MegaModel,
                  MegaPreTrainedModel,
              )

else:
       import sys

       a__: Union[str, Any]							   =						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





