






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 		_a       ( a					:List[str]      ,				a					:Dict      ,				a					:Optional[int]=None      ,				a					:Union[str, Any]=None					)				->     str:







 if attention_mask is None:
  a						    = tf.cast(tf.math.not_equal(a      ,				config.pad_token_id					)      ,				tf.inta					)
 return {"input_ids": input_ids, "attention_mask": attention_mask}






@require_tf
class 						lowercase_   :






      '''simple docstring'''




      __snake_case	    =    OPTConfig
      __snake_case	    =    {}
      __snake_case	    =    '''gelu'''







      def __init__( self :		Optional[Any]					,   __UpperCAmelCase :		Optional[int]					,   __UpperCAmelCase :		int=13					,   __UpperCAmelCase :		Any=7					,   __UpperCAmelCase :		Tuple=True					,   __UpperCAmelCase :		List[Any]=False					,   __UpperCAmelCase :		str=99					,   __UpperCAmelCase :		str=16					,   __UpperCAmelCase :		List[str]=2					,   __UpperCAmelCase :		Optional[int]=4					,   __UpperCAmelCase :		List[str]=4					,   __UpperCAmelCase :		List[Any]="gelu"					,   __UpperCAmelCase :		Dict=0.1					,   __UpperCAmelCase :		Dict=0.1					,   __UpperCAmelCase :		Any=20					,   __UpperCAmelCase :		List[str]=2					,   __UpperCAmelCase :		Any=1					,   __UpperCAmelCase :		List[Any]=0					,   __UpperCAmelCase :		Dict=16					,   __UpperCAmelCase :		Any=16					,   )       ->Tuple:




       """simple docstring"""


       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  __lowerCAmelCase   ( self :		Dict    )       ->Any:




       """simple docstring"""


       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=__UpperCAmelCase					,   **self.config_updates					,   )
       a						    = prepare_opt_inputs_dict(__UpperCAmelCase					,   __UpperCAmelCase    )
       return config, inputs_dict







      def  __lowerCAmelCase   ( self :		Tuple					,   __UpperCAmelCase :		List[str]					,   __UpperCAmelCase :		Union[str, Any]    )       ->List[str]:




       """simple docstring"""


       a						    = TFOPTModel(config=__UpperCAmelCase    )
       a						    = inputs_dict['''input_ids''']

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

       # first forward pass
       a						    = model(__UpperCAmelCase					,   attention_mask=__UpperCAmelCase					,   use_cache=__UpperCAmelCase    )

       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(__UpperCAmelCase					,   attention_mask=__UpperCAmelCase    )[0]
       a						    = model(__UpperCAmelCase					,   attention_mask=__UpperCAmelCase					,   past_key_values=__UpperCAmelCase    )[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(__UpperCAmelCase					,   __UpperCAmelCase					,   rtol=1e-3    )






@require_tf
class 						lowercase_   (      SCREAMING_SNAKE_CASE__					,    SCREAMING_SNAKE_CASE__					,    unittest.TestCase  ):






      '''simple docstring'''




      __snake_case	    =    (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
      __snake_case	    =    (TFOPTForCausalLM,) if is_tf_available() else ()
      __snake_case	    =    (
          {'''feature-extraction''': TFOPTModel, '''text-generation''': TFOPTForCausalLM} if is_tf_available() else {}
      )
      __snake_case	    =    False
      __snake_case	    =    False
      __snake_case	    =    False
      __snake_case	    =    10







      def  __lowerCAmelCase   ( self :		Optional[int]    )       ->int:




       """simple docstring"""


       a						    = TFOPTModelTester(self    )
       a						    = ConfigTester(self					,   config_class=__UpperCAmelCase    )







      def  __lowerCAmelCase   ( self :		Any    )       ->List[str]:




       """simple docstring"""


       self.config_tester.run_common_tests()







      def  __lowerCAmelCase   ( self :		Dict    )       ->Optional[Any]:




       """simple docstring"""


       a						    = self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_decoder_model_past_large_inputs(*__UpperCAmelCase    )







      def  __lowerCAmelCase   ( self :		List[Any]    )       ->List[Any]:




       """simple docstring"""


       a    ,	a						    = self.model_tester.prepare_config_and_inputs_for_common()

       def _get_word_embedding_weight(__UpperCAmelCase :		Optional[Any]					,   __UpperCAmelCase :		Tuple    ):
        if hasattr(__UpperCAmelCase					,   '''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(__UpperCAmelCase					,   '''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=__UpperCAmelCase    )
         a						    = _get_word_embedding_weight(__UpperCAmelCase					,   model.get_input_embeddings()    )
         a						    = _get_word_embedding_weight(__UpperCAmelCase					,   model.get_output_embeddings()    )

         # reshape the embeddings
         model.resize_token_embeddings(__UpperCAmelCase    )
         a						    = _get_word_embedding_weight(__UpperCAmelCase					,   model.get_input_embeddings()    )
         a						    = _get_word_embedding_weight(__UpperCAmelCase					,   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]					,   __UpperCAmelCase    )

         # 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(__UpperCAmelCase    )

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

          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(__UpperCAmelCase    )
def 		_a       ( a					:str					)				->     List[str]:
 return tf.constant(a      ,				dtype=tf.intaa					)






@require_tf
class 						lowercase_   (      unittest.TestCase  ):






      '''simple docstring'''




      __snake_case	    =    99







      def  __lowerCAmelCase   ( self :		str    )       ->Dict:




       """simple docstring"""


       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 						lowercase_   (      unittest.TestCase  ):






      '''simple docstring'''




      @slow
      def  __lowerCAmelCase   ( self :		Optional[Any]    )       ->List[Any]:




       """simple docstring"""


       a						    = TFOPTModel.from_pretrained('''facebook/opt-350m'''    )
       a						    = _long_tensor([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]]    )
       a						    = tf.not_equal(__UpperCAmelCase					,   model.config.pad_token_id    )
       with tf.GradientTape():
        a						    = model(input_ids=__UpperCAmelCase					,   attention_mask=__UpperCAmelCase    ).last_hidden_state
       a						    = (1, 11, 512)
       self.assertEqual(output.shape					,   __UpperCAmelCase    )
       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]					,   __UpperCAmelCase					,   atol=4e-3    )    )

       a						    = tf.function(__UpperCAmelCase					,   jit_compile=__UpperCAmelCase    )
       a						    = xla_generate(__UpperCAmelCase					,   __UpperCAmelCase    )[0]
       self.assertTrue(np.allclose(output[:, :3, :3]					,   __UpperCAmelCase					,   atol=4e-2    )    )






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






      '''simple docstring'''




      def  __lowerCAmelCase   ( self :		Dict    )       ->List[Any]:




       """simple docstring"""


       super().setUp()
       a						    = '''facebook/opt-350m'''







      def  __lowerCAmelCase   ( self :		Optional[Any]    )       ->List[str]:




       """simple docstring"""


       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(__UpperCAmelCase					,   return_tensors='''tf'''					,   padding=__UpperCAmelCase					,   add_special_tokens=__UpperCAmelCase    )
       a						    = tf.math.reduce_mean(model(inputs.input_ids					,   attention_mask=inputs.attention_mask    )[0]					,   axis=-1    )
       a						    = tf.constant(
           [
               [1.3851, -13.8_923, -10.5_229, -10.7_533, -0.2309, -10.2_384, -0.5365, -9.0947, -5.1670],
               [-4.7073, -10.6_276, -3.9415, -21.5_242, -0.2822, -0.2822, -0.2822, -0.2822, -0.2822],
               [0.6247, -3.4229, -8.9179, -1.4297, -14.1_650, 1.4146, -9.0218, -0.2703, -0.2703],
               [6.4783, -1.9913, -10.7_926, -2.3336, 1.5092, -0.9974, -6.8213, 1.3477, 1.3477],
           ]    )
       self.assertTrue(np.allclose(__UpperCAmelCase					,   __UpperCAmelCase					,   atol=1e-4    )    )

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






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






      '''simple docstring'''




      @property
      def  __lowerCAmelCase   ( self :		str    )       ->Any:




       """simple docstring"""


       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  __lowerCAmelCase   ( self :		Optional[Any]    )       ->Any:




       """simple docstring"""


       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(__UpperCAmelCase    )
       a						    = TFOPTForCausalLM.from_pretrained(__UpperCAmelCase    )

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

        a						    = model.generate(__UpperCAmelCase					,   max_length=10    )

        a						    = tokenizer.batch_decode(__UpperCAmelCase					,   skip_special_tokens=__UpperCAmelCase    )
        predicted_outputs += generated_string

       self.assertListEqual(__UpperCAmelCase					,   __UpperCAmelCase    )







      def  __lowerCAmelCase   ( self :		Optional[Any]    )       ->List[str]:




       """simple docstring"""


       a						    = '''facebook/opt-350m'''

       a						    = GPTaTokenizer.from_pretrained(__UpperCAmelCase    )
       a						    = TFOPTForCausalLM.from_pretrained(__UpperCAmelCase    )

       a						    = '''left'''

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

       a						    = tokenizer(__UpperCAmelCase					,   return_tensors='''tf'''					,   padding=__UpperCAmelCase    )
       a						    = inputs['''input_ids''']

       a						    = model.generate(input_ids=__UpperCAmelCase					,   attention_mask=inputs['''attention_mask''']    )

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

       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=__UpperCAmelCase					,   max_length=model.config.max_length - num_paddings    )

       a						    = tokenizer.batch_decode(__UpperCAmelCase					,   skip_special_tokens=__UpperCAmelCase    )
       a						    = tokenizer.decode(output_non_padded[0]					,   skip_special_tokens=__UpperCAmelCase    )
       a						    = tokenizer.decode(output_padded[0]					,   skip_special_tokens=__UpperCAmelCase    )

       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(__UpperCAmelCase					,   __UpperCAmelCase    )
       self.assertListEqual(__UpperCAmelCase					,   [non_padded_sentence, padded_sentence]    )







      def  __lowerCAmelCase   ( self :		List[Any]    )       ->Optional[Any]:




       """simple docstring"""


       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(__UpperCAmelCase    )
       a						    = TFOPTForCausalLM.from_pretrained(__UpperCAmelCase    )

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

        a						    = model.generate(__UpperCAmelCase					,   max_length=10    )

        a						    = tokenizer.batch_decode(__UpperCAmelCase					,   skip_special_tokens=__UpperCAmelCase    )
        predicted_outputs += generated_string

       self.assertListEqual(__UpperCAmelCase					,   __UpperCAmelCase    )








def lowercase    (  SCREAMING_SNAKE_CASE )			->							int:


			'''simple docstring'''







			if not numbers:
						return 0

			if not isinstance(SCREAMING_SNAKE_CASE       ,    (list, tuple) ) or not all(
			    isinstance(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE ) for number in numbers ):
						raise ValueError('numbers must be an iterable of integers' )

			SCREAMING_SNAKE_CASE_								=						SCREAMING_SNAKE_CASE_								=						SCREAMING_SNAKE_CASE_								=						numbers[0]

			for i in range(1       ,    len(SCREAMING_SNAKE_CASE ) ):
						# update the maximum and minimum subarray products
						SCREAMING_SNAKE_CASE_								=						numbers[i]
						if number < 0:
									SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						min_till_now, max_till_now
						SCREAMING_SNAKE_CASE_								=						max(SCREAMING_SNAKE_CASE       ,    max_till_now * number )
						SCREAMING_SNAKE_CASE_								=						min(SCREAMING_SNAKE_CASE       ,    min_till_now * number )

						# update the maximum product found till now
						SCREAMING_SNAKE_CASE_								=						max(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )

			return max_prod
