



'''simple docstring'''





from typing import TYPE_CHECKING

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


a_			=					{'''configuration_mmbt''': ['''MMBTConfig''']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a_			=					['''MMBTForClassification''', '''MMBTModel''', '''ModalEmbeddings''']


if TYPE_CHECKING:
  from .configuration_mmbt import MMBTConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mmbt import MMBTForClassification, MMBTModel, ModalEmbeddings

else:
  import sys

  a_			=					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)











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__			(		_UpperCamelCase			: Optional[int] ,_UpperCamelCase			: List[str] ,_UpperCamelCase			: List[Any]=None ,_UpperCamelCase			: Any=None							):
   if attention_mask is None:
      __lowerCamelCase													=    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  __lowerCAmelCase     :
 lowerCAmelCase__       					=  OPTConfig
 lowerCAmelCase__       					=  {}
 lowerCAmelCase__       					=  """gelu"""




 def __init__(						self	,				__UpperCAmelCase	,				__UpperCAmelCase=13	,				__UpperCAmelCase=7	,				__UpperCAmelCase=True	,				__UpperCAmelCase=False	,				__UpperCAmelCase=99	,				__UpperCAmelCase=16	,				__UpperCAmelCase=2	,				__UpperCAmelCase=4	,				__UpperCAmelCase=4	,				__UpperCAmelCase="gelu"	,				__UpperCAmelCase=0.1	,				__UpperCAmelCase=0.1	,				__UpperCAmelCase=20	,				__UpperCAmelCase=2	,				__UpperCAmelCase=1	,				__UpperCAmelCase=0	,				__UpperCAmelCase=16	,				__UpperCAmelCase=16	,				):



    '''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        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    TFOPTModel(config=__UpperCAmelCase				)
    __lowerCamelCase													=    inputs_dict['''input_ids''']

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

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

    __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(__UpperCAmelCase	,				attention_mask=__UpperCAmelCase				)[0]
    __lowerCamelCase													=    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
    __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(__UpperCAmelCase	,				__UpperCAmelCase	,				rtol=1E-3				)



@require_tf
class  __lowerCAmelCase     (	lowerCAmelCase__  ,	lowerCAmelCase__  ,	unittest.TestCase   ):
 lowerCAmelCase__       					=  (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
 lowerCAmelCase__       					=  (TFOPTForCausalLM,) if is_tf_available() else ()
 lowerCAmelCase__       					=  (
     {"""feature-extraction""": TFOPTModel, """text-generation""": TFOPTForCausalLM} if is_tf_available() else {}
 )
 lowerCAmelCase__       					=  False
 lowerCAmelCase__       					=  False
 lowerCAmelCase__       					=  False
 lowerCAmelCase__       					=  1_0




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    TFOPTModelTester(self				)
    __lowerCamelCase													=    ConfigTester(self	,				config_class=__UpperCAmelCase				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    self.config_tester.run_common_tests()




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    self.model_tester.prepare_config_and_inputs_for_common()
    self.model_tester.check_decoder_model_past_large_inputs(*__UpperCAmelCase				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase							,__lowerCamelCase													=    self.model_tester.prepare_config_and_inputs_for_common()

    def _get_word_embedding_weight(__UpperCAmelCase	,				__UpperCAmelCase				):
       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
          __lowerCamelCase													=    model_class(config=__UpperCAmelCase				)
          __lowerCamelCase													=    _get_word_embedding_weight(__UpperCAmelCase	,				model.get_input_embeddings()				)
          __lowerCamelCase													=    _get_word_embedding_weight(__UpperCAmelCase	,				model.get_output_embeddings()				)

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

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

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

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





def 		a__			(		_UpperCamelCase			: Optional[Any]							):
   return tf.constant(_UpperCamelCase ,dtype=tf.intaa							)



@require_tf
class  __lowerCAmelCase     (	unittest.TestCase   ):
 lowerCAmelCase__       					=  9_9




 def        lowerCamelCase      (						self				):



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




 @slow
 def        lowerCamelCase      (						self				):



    '''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(__UpperCAmelCase	,				model.config.pad_token_id				)
    with tf.GradientTape():
       __lowerCamelCase													=    model(input_ids=__UpperCAmelCase	,				attention_mask=__UpperCAmelCase				).last_hidden_state
    __lowerCamelCase													=    (1, 11, 512)
    self.assertEqual(output.shape	,				__UpperCAmelCase				)
    __lowerCamelCase													=    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]	,				__UpperCAmelCase	,				atol=4E-3				)				)

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



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




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    super().setUp()
    __lowerCamelCase													=    '''facebook/opt-350m'''




 def        lowerCamelCase      (						self				):



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

    __lowerCamelCase													=    tf.function(__UpperCAmelCase	,				jit_compile=__UpperCAmelCase				)
    __lowerCamelCase													=    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  __lowerCAmelCase     (	unittest.TestCase   ):




 @property
 def        lowerCamelCase      (						self				):



    '''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				):



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

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

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

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

    self.assertListEqual(__UpperCAmelCase	,				__UpperCAmelCase				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    '''facebook/opt-350m'''

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

    __lowerCamelCase													=    '''left'''

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

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

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

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

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

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

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




 def        lowerCamelCase      (						self				):



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

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

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

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

    self.assertListEqual(__UpperCAmelCase	,				__UpperCAmelCase				)






