




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_			,    lowercase_			,    lowercase_=None			,    lowercase_=None						)       ->	Optional[int]:



       """simple docstring"""

       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     UpperCamelCase_   :

    '''simple docstring'''






    UpperCAmelCase__							  =				OPTConfig
    UpperCAmelCase__							  =				{}
    UpperCAmelCase__							  =				"gelu"


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





           '''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 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->int:





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





    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any] ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Union[str, Any])						->Union[str, Any]:





           '''simple docstring'''

           A__							=   TFOPTModel(config=_a)
           A__							=   inputs_dict['''input_ids''']

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

           # first forward pass
           A__							=   model(_a ,			attention_mask=_a ,			use_cache=_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(_a ,			attention_mask=_a)[0]
           A__							=   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
           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(_a ,			_a ,			rtol=1e-3)


@require_tf
class     UpperCamelCase_   (			__lowercase		, __lowercase		, 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 	SCREAMING_SNAKE_CASE							(      self				:     str)						->int:





           '''simple docstring'''

           A__							=   TFOPTModelTester(self)
           A__							=   ConfigTester(self ,			config_class=_a)


    def 	SCREAMING_SNAKE_CASE							(      self				:     Tuple)						->Optional[int]:





           '''simple docstring'''

           self.config_tester.run_common_tests()


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





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_decoder_model_past_large_inputs(*_a)





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





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs_for_common()

           def _get_word_embedding_weight(UpperCAmelCase__				:     List[Any] ,			UpperCAmelCase__				:     Tuple):
                  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
                         A__							=   model_class(config=_a)
                         A__							=   _get_word_embedding_weight(_a ,			model.get_input_embeddings())
                         A__							=   _get_word_embedding_weight(_a ,			model.get_output_embeddings())

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

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

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

                                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(_a)







def SCREAMING_SNAKE_CASE    (	lowercase_						)       ->	Dict:



       """simple docstring"""

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


@require_tf
class     UpperCamelCase_   (			unittest.TestCase					):

    '''simple docstring'''






    UpperCAmelCase__							  =				99


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[str])						->List[str]:





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

    '''simple docstring'''






    @slow
    def 	SCREAMING_SNAKE_CASE							(      self				:     int)						->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(_a ,			model.config.pad_token_id)
           with tf.GradientTape():
                  A__							=   model(input_ids=_a ,			attention_mask=_a).last_hidden_state
           A__							=   (1, 11, 512)
           self.assertEqual(output.shape ,			_a)
           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] ,			_a ,			atol=4e-3))

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


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

    '''simple docstring'''






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





           '''simple docstring'''

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





    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->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(_a ,			return_tensors='''tf''' ,			padding=_a ,			add_special_tokens=_a)
           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(_a ,			_a ,			atol=1e-4))

           A__							=   tf.function(_a ,			jit_compile=_a)
           A__							=   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     UpperCamelCase_   (			unittest.TestCase					):

    '''simple docstring'''






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





           '''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(_a)
           A__							=   TFOPTForCausalLM.from_pretrained(_a)

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

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

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

           self.assertListEqual(_a ,			_a)


    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->Tuple:





           '''simple docstring'''

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

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

           A__							=   '''left'''

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

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

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

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

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

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

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





    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->str:





           '''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(_a)
           A__							=   TFOPTForCausalLM.from_pretrained(_a)

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

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

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

           self.assertListEqual(_a ,			_a)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


_lowerCamelCase     :		Tuple								=       {
    """configuration_speech_to_text""": ["""SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """Speech2TextConfig"""],
    """processing_speech_to_text""": ["""Speech2TextProcessor"""],
}

try:
  if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase     :		int								=       ["""Speech2TextTokenizer"""]

try:
  if not is_speech_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase     :		Optional[int]								=       ["""Speech2TextFeatureExtractor"""]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase     :		Optional[Any]								=       [
      """TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFSpeech2TextForConditionalGeneration""",
      """TFSpeech2TextModel""",
      """TFSpeech2TextPreTrainedModel""",
  ]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase     :		List[Any]								=       [
      """SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """Speech2TextForConditionalGeneration""",
      """Speech2TextModel""",
      """Speech2TextPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
  from .processing_speech_to_text import SpeechaTextProcessor

  try:
    if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_speech_to_text import SpeechaTextTokenizer

  try:
    if not is_speech_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_speech_to_text import (
        TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFSpeechaTextForConditionalGeneration,
        TFSpeechaTextModel,
        TFSpeechaTextPreTrainedModel,
    )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_speech_to_text import (
        SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
        SpeechaTextForConditionalGeneration,
        SpeechaTextModel,
        SpeechaTextPreTrainedModel,
    )

else:
  import sys

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


