




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       _SCREAMING_SNAKE_CASE      (							lowercase     :	Union[str, Any]     ,							lowercase     :	str     ,							lowercase     :	Tuple=None     ,							lowercase     :	Optional[int]=None					):


      '''simple docstring'''



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







@require_tf
class   A:



 '''simple docstring'''


 UpperCamelCase						       =						OPTConfig
 UpperCamelCase						       =						{}
 UpperCamelCase						       =						'''gelu'''

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

       """simple docstring"""






       lowerCamelCase_							=   parent
       lowerCamelCase_							=   batch_size
       lowerCamelCase_							=   seq_length
       lowerCamelCase_							=   is_training
       lowerCamelCase_							=   use_labels
       lowerCamelCase_							=   vocab_size
       lowerCamelCase_							=   hidden_size
       lowerCamelCase_							=   num_hidden_layers
       lowerCamelCase_							=   num_attention_heads
       lowerCamelCase_							=   intermediate_size
       lowerCamelCase_							=   hidden_act
       lowerCamelCase_							=   hidden_dropout_prob
       lowerCamelCase_							=   attention_probs_dropout_prob
       lowerCamelCase_							=   max_position_embeddings
       lowerCamelCase_							=   eos_token_id
       lowerCamelCase_							=   pad_token_id
       lowerCamelCase_							=   bos_token_id
       lowerCamelCase_							=   embed_dim
       lowerCamelCase_							=   word_embed_proj_dim
       lowerCamelCase_							=   False

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

       """simple docstring"""






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

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





 def     a__			(    self :  Optional[int]						,							A_ :  Optional[int]						,							A_ :  List[Any]  )       ->     Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_							=   TFOPTModel(config=A_  )
       lowerCamelCase_							=   inputs_dict['input_ids']

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

       # first forward pass
       lowerCamelCase_							=   model(A_						,							attention_mask=A_						,							use_cache=A_  )

       lowerCamelCase_					,    lowerCamelCase_							=   outputs.to_tuple()

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

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

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

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







@require_tf
class   A(						UpperCamelCase							,				UpperCamelCase							,				unittest.TestCase       ):



 '''simple docstring'''


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

 def     a__			(    self :  str  )       ->     Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=   TFOPTModelTester(self  )
       lowerCamelCase_							=   ConfigTester(self						,							config_class=A_  )

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

       """simple docstring"""






       self.config_tester.run_common_tests()

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

       """simple docstring"""






       lowerCamelCase_							=   self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_decoder_model_past_large_inputs(*A_  )





 def     a__			(    self :  Dict  )       ->     Optional[int]:

       """simple docstring"""






       lowerCamelCase_					,    lowerCamelCase_							=   self.model_tester.prepare_config_and_inputs_for_common()

       def _get_word_embedding_weight(A_ :  Optional[int]						,							A_ :  List[Any]  ):
             if hasattr(A_						,							'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(A_						,							'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
                   lowerCamelCase_							=   model_class(config=A_  )
                   lowerCamelCase_							=   _get_word_embedding_weight(A_						,							model.get_input_embeddings()  )
                   lowerCamelCase_							=   _get_word_embedding_weight(A_						,							model.get_output_embeddings()  )

                   # reshape the embeddings
                   model.resize_token_embeddings(A_  )
                   lowerCamelCase_							=   _get_word_embedding_weight(A_						,							model.get_input_embeddings()  )
                   lowerCamelCase_							=   _get_word_embedding_weight(A_						,							model.get_output_embeddings()  )

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

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

                   # check that weights remain the same after resizing
                   lowerCamelCase_							=   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:
                               lowerCamelCase_							=   False
                   self.assertTrue(A_  )

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

                         lowerCamelCase_							=   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:
                                     lowerCamelCase_							=   False
                         self.assertTrue(A_  )

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	Optional[int]					):


      '''simple docstring'''



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







@require_tf
class   A(						unittest.TestCase       ):



 '''simple docstring'''


 UpperCamelCase						       =						99

 def     a__			(    self :  Union[str, Any]  )       ->     Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=   tf.ones((4, 1)						,							dtype=tf.intaa  ) * 2
       lowerCamelCase_							=   tf.concat([ids_tensor((4, 6)						,							self.vocab_size - 3  ) + 3, eos_column_vector]						,							axis=1  )
       lowerCamelCase_							=   input_ids.shape[0]
       lowerCamelCase_							=   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   A(						unittest.TestCase       ):



 '''simple docstring'''


 @slow
 def     a__			(    self :  Tuple  )       ->     Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=   TFOPTModel.from_pretrained('facebook/opt-350m'  )
       lowerCamelCase_							=   _long_tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]  )
       lowerCamelCase_							=   tf.not_equal(A_						,							model.config.pad_token_id  )
       with tf.GradientTape():
             lowerCamelCase_							=   model(input_ids=A_						,							attention_mask=A_  ).last_hidden_state
       lowerCamelCase_							=   (1, 11, 512)
       self.assertEqual(output.shape						,							A_  )
       lowerCamelCase_							=   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]						,							A_						,							atol=4E-3  )  )

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







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



 '''simple docstring'''


 def     a__			(    self :  Any  )       ->     Dict:

       """simple docstring"""






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





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

       """simple docstring"""






       lowerCamelCase_							=   TFOPTForCausalLM.from_pretrained(self.path_model  )
       lowerCamelCase_							=   GPTaTokenizer.from_pretrained(self.path_model  )

       lowerCamelCase_							=   [
           '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
       lowerCamelCase_							=   tokenizer(A_						,							return_tensors='tf'						,							padding=A_						,							add_special_tokens=A_  )
       lowerCamelCase_							=   tf.math.reduce_mean(model(inputs.input_ids						,							attention_mask=inputs.attention_mask  )[0]						,							axis=-1  )
       lowerCamelCase_							=   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(A_						,							A_						,							atol=1E-4  )  )

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







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



 '''simple docstring'''


 @property
 def     a__			(    self :  List[Any]  )       ->     Dict:

       """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     a__			(    self :  List[Any]  )       ->     int:

       """simple docstring"""






       lowerCamelCase_							=   'facebook/opt-125m'

       lowerCamelCase_							=   [
           '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',
       ]

       lowerCamelCase_							=   []
       lowerCamelCase_							=   GPTaTokenizer.from_pretrained(A_  )
       lowerCamelCase_							=   TFOPTForCausalLM.from_pretrained(A_  )

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

             lowerCamelCase_							=   model.generate(A_						,							max_length=10  )

             lowerCamelCase_							=   tokenizer.batch_decode(A_						,							skip_special_tokens=A_  )
             predicted_outputs += generated_string

       self.assertListEqual(A_						,							A_  )

 def     a__			(    self :  Optional[int]  )       ->     List[str]:

       """simple docstring"""






       lowerCamelCase_							=   'facebook/opt-350m'

       lowerCamelCase_							=   GPTaTokenizer.from_pretrained(A_  )
       lowerCamelCase_							=   TFOPTForCausalLM.from_pretrained(A_  )

       lowerCamelCase_							=   'left'

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

       lowerCamelCase_							=   tokenizer(A_						,							return_tensors='tf'						,							padding=A_  )
       lowerCamelCase_							=   inputs['input_ids']

       lowerCamelCase_							=   model.generate(input_ids=A_						,							attention_mask=inputs['attention_mask']  )

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

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

       lowerCamelCase_							=   tokenizer.batch_decode(A_						,							skip_special_tokens=A_  )
       lowerCamelCase_							=   tokenizer.decode(output_non_padded[0]						,							skip_special_tokens=A_  )
       lowerCamelCase_							=   tokenizer.decode(output_padded[0]						,							skip_special_tokens=A_  )

       lowerCamelCase_							=   [
           '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(A_						,							A_  )
       self.assertListEqual(A_						,							[non_padded_sentence, padded_sentence]  )





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

       """simple docstring"""






       lowerCamelCase_							=   'facebook/opt-350m'

       lowerCamelCase_							=   [
           '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',
       ]

       lowerCamelCase_							=   []
       lowerCamelCase_							=   GPTaTokenizer.from_pretrained(A_  )
       lowerCamelCase_							=   TFOPTForCausalLM.from_pretrained(A_  )

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

             lowerCamelCase_							=   model.generate(A_						,							max_length=10  )

             lowerCamelCase_							=   tokenizer.batch_decode(A_						,							skip_special_tokens=A_  )
             predicted_outputs += generated_string

       self.assertListEqual(A_						,							A_  )









import math

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	float     ,							lowercase     :	float					):


      '''simple docstring'''



      return math.pow(lowercase     ,							2					) - a

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	float					):


      '''simple docstring'''



      return 2 * x

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	float					):


      '''simple docstring'''



      lowerCamelCase_							=   2.0

      while start <= a:
            lowerCamelCase_							=   math.pow(lowercase     ,							2					)

      return start

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	float     ,							lowercase     :	int = 99_99     ,							lowercase     :	float = 0.00_0000_0000_0001					):


      '''simple docstring'''



      if a < 0:
            raise ValueError('math domain error'					)

      lowerCamelCase_							=   get_initial_point(lowercase					)

      for _ in range(lowercase					):
            lowerCamelCase_							=   value
            lowerCamelCase_							=   value - fx(lowercase     ,							lowercase					) / fx_derivative(lowercase					)
            if abs(prev_value - value					) < tolerance:
                  return value

      return value


if __name__ == "__main__":
 from doctest import testmod

 testmod()



