


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      :			List[Any]						,	UpperCAmelCase      :			int						,	UpperCAmelCase      :			Optional[Any]=None						,	UpperCAmelCase      :			Any=None      ):
      """simple docstring"""




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



@require_tf
class 							_UpperCamelCase :

   '''simple docstring'''







   a_				:							Optional[Any]    = OPTConfig
   a_				:							List[Any]    = {}
   a_				:							Union[str, Any]    = "gelu"

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






         '''simple docstring'''



         __lowerCamelCase     :      Optional[int]       						=						parent
         __lowerCamelCase     :      Optional[Any]       						=						batch_size
         __lowerCamelCase     :      Optional[int]       						=						seq_length
         __lowerCamelCase     :      List[str]       						=						is_training
         __lowerCamelCase     :      List[str]       						=						use_labels
         __lowerCamelCase     :      str       						=						vocab_size
         __lowerCamelCase     :      Union[str, Any]       						=						hidden_size
         __lowerCamelCase     :      Union[str, Any]       						=						num_hidden_layers
         __lowerCamelCase     :      List[Any]       						=						num_attention_heads
         __lowerCamelCase     :      Optional[int]       						=						intermediate_size
         __lowerCamelCase     :      Optional[Any]       						=						hidden_act
         __lowerCamelCase     :      List[Any]       						=						hidden_dropout_prob
         __lowerCamelCase     :      List[Any]       						=						attention_probs_dropout_prob
         __lowerCamelCase     :      str       						=						max_position_embeddings
         __lowerCamelCase     :      Union[str, Any]       						=						eos_token_id
         __lowerCamelCase     :      Tuple       						=						pad_token_id
         __lowerCamelCase     :      Tuple       						=						bos_token_id
         __lowerCamelCase     :      List[str]       						=						embed_dim
         __lowerCamelCase     :      int       						=						word_embed_proj_dim
         __lowerCamelCase     :      List[Any]       						=						False

   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



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

         __lowerCamelCase     :      List[Any]       						=						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=lowercase_       ,  **self.config_updates       ,  )
         __lowerCamelCase     :      Union[str, Any]       						=						prepare_opt_inputs_dict(lowercase_       ,  lowercase_							)
         return config, inputs_dict


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






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						TFOPTModel(config=lowercase_							)
         __lowerCamelCase     :      List[Any]       						=						inputs_dict["input_ids"]

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

         # first forward pass
         __lowerCamelCase     :      Dict       						=						model(lowercase_       ,  attention_mask=lowercase_       ,  use_cache=lowercase_							)

         __lowerCamelCase     :      Optional[Any]       						=						outputs.to_tuple()

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

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

         __lowerCamelCase     :      Dict       						=						model(lowercase_       ,  attention_mask=lowercase_							)[0]
         __lowerCamelCase     :      str       						=						model(lowercase_       ,  attention_mask=lowercase_       ,  past_key_values=lowercase_							)[0]

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

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

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



@require_tf
class 							_UpperCamelCase (						snake_case__,snake_case__,unittest.TestCase						):

   '''simple docstring'''







   a_				:							str    = (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
   a_				:							List[str]    = (TFOPTForCausalLM,) if is_tf_available() else ()
   a_				:							List[str]    = (
       {"feature-extraction": TFOPTModel, "text-generation": TFOPTForCausalLM} if is_tf_available() else {}
   )
   a_				:							Any    = False
   a_				:							Optional[int]    = False
   a_				:							int    = False
   a_				:							Dict    = 10

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						TFOPTModelTester(self							)
         __lowerCamelCase     :      List[Any]       						=						ConfigTester(self       ,  config_class=lowercase_							)

   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         self.config_tester.run_common_tests()

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.check_decoder_model_past_large_inputs(*lowercase_							)


   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						self.model_tester.prepare_config_and_inputs_for_common()

         def _get_word_embedding_weight(_lowerCamelCase  : List[str]       ,  _lowerCamelCase  : str							):
               if hasattr(lowercase_       ,  """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(lowercase_       ,  """weight"""							):
                           return embedding_layer.weight
                     else:
                           return None

         for model_class in self.all_model_classes:
               for size in [config.vocab_size - 1_0, config.vocab_size + 1_0]:
                     # build the embeddings
                     __lowerCamelCase     :      List[str]       						=						model_class(config=lowercase_							)
                     __lowerCamelCase     :      Union[str, Any]       						=						_get_word_embedding_weight(lowercase_       ,  model.get_input_embeddings()							)
                     __lowerCamelCase     :      Any       						=						_get_word_embedding_weight(lowercase_       ,  model.get_output_embeddings()							)

                     # reshape the embeddings
                     model.resize_token_embeddings(lowercase_							)
                     __lowerCamelCase     :      Union[str, Any]       						=						_get_word_embedding_weight(lowercase_       ,  model.get_input_embeddings()							)
                     __lowerCamelCase     :      Tuple       						=						_get_word_embedding_weight(lowercase_       ,  model.get_output_embeddings()							)

                     # check that the resized embeddings size matches the desired size.
                     __lowerCamelCase     :      Optional[Any]       						=						size if size is not None else config.vocab_size

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

                     # check that weights remain the same after resizing
                     __lowerCamelCase     :      Any       						=						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     :      Optional[int]       						=						False
                     self.assertTrue(lowercase_							)

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

                           __lowerCamelCase     :      List[Any]       						=						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     :      Any       						=						False
                           self.assertTrue(lowercase_							)





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




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



@require_tf
class 							_UpperCamelCase (						unittest.TestCase						):

   '''simple docstring'''







   a_				:							int    = 99

   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[int]       						=						tf.ones((4, 1)       ,  dtype=tf.intaa							) * 2
         __lowerCamelCase     :      List[Any]       						=						tf.concat([ids_tensor((4, 6)       ,  self.vocab_size - 3							) + 3, eos_column_vector]       ,  axis=1							)
         __lowerCamelCase     :      Tuple       						=						input_ids.shape[0]
         __lowerCamelCase     :      List[str]       						=						OPTConfig(
             vocab_size=self.vocab_size       ,  hidden_size=2_4       ,  num_hidden_layers=2       ,  num_attention_heads=2       ,  ffn_dim=3_2       ,  max_position_embeddings=4_8       ,  eos_token_id=2       ,  pad_token_id=1       ,  bos_token_id=0       ,  )
         return config, input_ids, batch_size



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

   '''simple docstring'''







   @slow
   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						TFOPTModel.from_pretrained("""facebook/opt-350m"""							)
         __lowerCamelCase     :      List[Any]       						=						_long_tensor([[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, 4_6_0_7_8, 1_5_8_8, 2]]							)
         __lowerCamelCase     :      int       						=						tf.not_equal(lowercase_       ,  model.config.pad_token_id							)
         with tf.GradientTape():
               __lowerCamelCase     :      Optional[Any]       						=						model(input_ids=lowercase_       ,  attention_mask=lowercase_							).last_hidden_state
         __lowerCamelCase     :      Union[str, Any]       						=						(1, 1_1, 5_1_2)
         self.assertEqual(output.shape       ,  lowercase_							)
         __lowerCamelCase     :      Optional[int]       						=						tf.constant(
             [[-0.2_873, -1.9_218, -0.3_033], [-1.2_710, -0.1_338, -0.1_902], [0.4_095, 0.1_214, -1.3_121]]							)
         self.assertTrue(np.allclose(output[:, :3, :3]       ,  lowercase_       ,  atol=4E-3							)							)

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



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

   '''simple docstring'''







   def   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         super().setUp()
         __lowerCamelCase     :      Tuple       						=						"facebook/opt-350m"


   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						TFOPTForCausalLM.from_pretrained(self.path_model							)
         __lowerCamelCase     :      str       						=						GPTaTokenizer.from_pretrained(self.path_model							)

         __lowerCamelCase     :      Optional[Any]       						=						[
             "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     :      Union[str, Any]       						=						tokenizer(lowercase_       ,  return_tensors="""tf"""       ,  padding=lowercase_       ,  add_special_tokens=lowercase_							)
         __lowerCamelCase     :      List[Any]       						=						tf.math.reduce_mean(model(inputs.input_ids       ,  attention_mask=inputs.attention_mask							)[0]       ,  axis=-1							)
         __lowerCamelCase     :      List[Any]       						=						tf.constant(
             [
                 [1.3_851, -13.8_923, -10.5_229, -10.7_533, -0.2_309, -10.2_384, -0.5_365, -9.0_947, -5.1_670],
                 [-4.7_073, -10.6_276, -3.9_415, -21.5_242, -0.2_822, -0.2_822, -0.2_822, -0.2_822, -0.2_822],
                 [0.6_247, -3.4_229, -8.9_179, -1.4_297, -14.1_650, 1.4_146, -9.0_218, -0.2_703, -0.2_703],
                 [6.4_783, -1.9_913, -10.7_926, -2.3_336, 1.5_092, -0.9_974, -6.8_213, 1.3_477, 1.3_477],
             ]							)
         self.assertTrue(np.allclose(lowercase_       ,  lowercase_       ,  atol=1E-4							)							)

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



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

   '''simple docstring'''







   @property
   def   _snake_case    (  self  : 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   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						"facebook/opt-125m"

         __lowerCamelCase     :      Union[str, Any]       						=						[
             "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     :      Dict       						=						[]
         __lowerCamelCase     :      int       						=						GPTaTokenizer.from_pretrained(lowercase_							)
         __lowerCamelCase     :      Optional[Any]       						=						TFOPTForCausalLM.from_pretrained(lowercase_							)

         for prompt in self.prompts:
               __lowerCamelCase     :      str       						=						tokenizer(lowercase_       ,  return_tensors="""tf"""							).input_ids

               __lowerCamelCase     :      Optional[int]       						=						model.generate(lowercase_       ,  max_length=1_0							)

               __lowerCamelCase     :      int       						=						tokenizer.batch_decode(lowercase_       ,  skip_special_tokens=lowercase_							)
               predicted_outputs += generated_string

         self.assertListEqual(lowercase_       ,  lowercase_							)

   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						"facebook/opt-350m"

         __lowerCamelCase     :      Tuple       						=						GPTaTokenizer.from_pretrained(lowercase_							)
         __lowerCamelCase     :      Union[str, Any]       						=						TFOPTForCausalLM.from_pretrained(lowercase_							)

         __lowerCamelCase     :      Union[str, Any]       						=						"left"

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

         __lowerCamelCase     :      Union[str, Any]       						=						tokenizer(lowercase_       ,  return_tensors="""tf"""       ,  padding=lowercase_							)
         __lowerCamelCase     :      Optional[Any]       						=						inputs["input_ids"]

         __lowerCamelCase     :      Optional[Any]       						=						model.generate(input_ids=lowercase_       ,  attention_mask=inputs["""attention_mask"""]							)

         __lowerCamelCase     :      List[str]       						=						tokenizer(sentences[0]       ,  return_tensors="""tf"""							).input_ids
         __lowerCamelCase     :      Any       						=						model.generate(input_ids=lowercase_							)

         __lowerCamelCase     :      int       						=						inputs_non_padded.shape[-1] - tf.math.reduce_sum(
             tf.cast(inputs["""attention_mask"""][-1]       ,  tf.intaa							)							)
         __lowerCamelCase     :      Dict       						=						tokenizer(sentences[1]       ,  return_tensors="""tf"""							).input_ids
         __lowerCamelCase     :      Any       						=						model.generate(input_ids=lowercase_       ,  max_length=model.config.max_length - num_paddings							)

         __lowerCamelCase     :      str       						=						tokenizer.batch_decode(lowercase_       ,  skip_special_tokens=lowercase_							)
         __lowerCamelCase     :      str       						=						tokenizer.decode(output_non_padded[0]       ,  skip_special_tokens=lowercase_							)
         __lowerCamelCase     :      Union[str, Any]       						=						tokenizer.decode(output_padded[0]       ,  skip_special_tokens=lowercase_							)

         __lowerCamelCase     :      Union[str, Any]       						=						[
             "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(lowercase_       ,  lowercase_							)
         self.assertListEqual(lowercase_       ,  [non_padded_sentence, padded_sentence]							)


   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						"facebook/opt-350m"

         __lowerCamelCase     :      Optional[Any]       						=						[
             "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     :      Any       						=						[]
         __lowerCamelCase     :      Dict       						=						GPTaTokenizer.from_pretrained(lowercase_							)
         __lowerCamelCase     :      int       						=						TFOPTForCausalLM.from_pretrained(lowercase_							)

         for prompt in self.prompts:
               __lowerCamelCase     :      List[Any]       						=						tokenizer(lowercase_       ,  return_tensors="""tf"""							).input_ids

               __lowerCamelCase     :      List[str]       						=						model.generate(lowercase_       ,  max_length=1_0							)

               __lowerCamelCase     :      Dict       						=						tokenizer.batch_decode(lowercase_       ,  skip_special_tokens=lowercase_							)
               predicted_outputs += generated_string

         self.assertListEqual(lowercase_       ,  lowercase_							)







from typing import Any





def   _UpperCAmelCase       (     UpperCAmelCase      :			list      ):
      """simple docstring"""




      if not input_list:
            return []
      __lowerCamelCase     :      int       						=						[input_list.count(UpperCAmelCase      ) for value in input_list]
      __lowerCamelCase     :      Tuple       						=						max(UpperCAmelCase      )  # Gets the maximum count in the input list.
      # Gets values of modes
      return sorted({input_list[i] for i, value in enumerate(UpperCAmelCase      ) if value == y}      )


if __name__ == "__main__":
    import doctest

    doctest.testmod()



