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						(    lowercase							,			lowercase							,			lowercase=None							,			lowercase=None							):







				"""simple docstring"""



				if attention_mask is None:
								__lowercase 			=							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    _UpperCamelCase      :


			"""simple docstring"""






			__a  : Tuple			 =						OPTConfig
			__a  : int			 =						{}
			__a  : Dict			 =						'''gelu'''





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

							'''simple docstring'''


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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


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

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





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					int:

							'''simple docstring'''


							__lowercase 			=							TFOPTModel(config=lowerCAmelCase__						)
							__lowercase 			=							inputs_dict['''input_ids''']

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

							# first forward pass
							__lowercase 			=							model(lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__      ,   use_cache=lowerCAmelCase__						)

							__lowercase			,     __lowercase 			=							outputs.to_tuple()

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

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

							__lowercase 			=							model(lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__						)[0]
							__lowercase 			=							model(lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__      ,   past_key_values=lowerCAmelCase__						)[0]

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

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

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




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


			"""simple docstring"""






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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							__lowercase 			=							TFOPTModelTester(self						)
							__lowercase 			=							ConfigTester(self      ,   config_class=lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							self.config_tester.run_common_tests()





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


							__lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							def _get_word_embedding_weight(lowerCAmelCase__      ,   lowerCAmelCase__						):
											if hasattr(lowerCAmelCase__      ,   '''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(lowerCAmelCase__      ,   '''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
															__lowercase 			=							model_class(config=lowerCAmelCase__						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_input_embeddings()						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_output_embeddings()						)

															# reshape the embeddings
															model.resize_token_embeddings(lowerCAmelCase__						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_input_embeddings()						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_output_embeddings()						)

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

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

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

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

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





def 				UpperCAmelCase						(    lowercase							):







				"""simple docstring"""



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




@require_tf
class    _UpperCamelCase      (						unittest.TestCase ):


			"""simple docstring"""






			__a  : List[str]			 =						99





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


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

							'''simple docstring'''


							__lowercase 			=							TFOPTModel.from_pretrained('''facebook/opt-350m'''						)
							__lowercase 			=							_long_tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]						)
							__lowercase 			=							tf.not_equal(lowerCAmelCase__      ,   model.config.pad_token_id						)
							with tf.GradientTape():
											__lowercase 			=							model(input_ids=lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__						).last_hidden_state
							__lowercase 			=							(1, 11, 5_12)
							self.assertEqual(output.shape      ,   lowerCAmelCase__						)
							__lowercase 			=							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]      ,   lowerCAmelCase__      ,   atol=4E-3						)						)

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




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


			"""simple docstring"""






			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


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

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

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




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


			"""simple docstring"""






			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					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        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


							__lowercase 			=							'''facebook/opt-125m'''

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

							__lowercase 			=							[]
							__lowercase 			=							GPTaTokenizer.from_pretrained(lowerCAmelCase__						)
							__lowercase 			=							TFOPTForCausalLM.from_pretrained(lowerCAmelCase__						)

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

											__lowercase 			=							model.generate(lowerCAmelCase__      ,   max_length=10						)

											__lowercase 			=							tokenizer.batch_decode(lowerCAmelCase__      ,   skip_special_tokens=lowerCAmelCase__						)
											predicted_outputs += generated_string

							self.assertListEqual(lowerCAmelCase__      ,   lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


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

							__lowercase 			=							GPTaTokenizer.from_pretrained(lowerCAmelCase__						)
							__lowercase 			=							TFOPTForCausalLM.from_pretrained(lowerCAmelCase__						)

							__lowercase 			=							'''left'''

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

							__lowercase 			=							tokenizer(lowerCAmelCase__      ,   return_tensors='''tf'''      ,   padding=lowerCAmelCase__						)
							__lowercase 			=							inputs['''input_ids''']

							__lowercase 			=							model.generate(input_ids=lowerCAmelCase__      ,   attention_mask=inputs['''attention_mask''']						)

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

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

							__lowercase 			=							tokenizer.batch_decode(lowerCAmelCase__      ,   skip_special_tokens=lowerCAmelCase__						)
							__lowercase 			=							tokenizer.decode(output_non_padded[0]      ,   skip_special_tokens=lowerCAmelCase__						)
							__lowercase 			=							tokenizer.decode(output_padded[0]      ,   skip_special_tokens=lowerCAmelCase__						)

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





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

							'''simple docstring'''


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

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

							__lowercase 			=							[]
							__lowercase 			=							GPTaTokenizer.from_pretrained(lowerCAmelCase__						)
							__lowercase 			=							TFOPTForCausalLM.from_pretrained(lowerCAmelCase__						)

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

											__lowercase 			=							model.generate(lowerCAmelCase__      ,   max_length=10						)

											__lowercase 			=							tokenizer.batch_decode(lowerCAmelCase__      ,   skip_special_tokens=lowerCAmelCase__						)
											predicted_outputs += generated_string

							self.assertListEqual(lowerCAmelCase__      ,   lowerCAmelCase__						)
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						(    lowercase							,			lowercase							,			lowercase=None							,			lowercase=None							):







				"""simple docstring"""



				if attention_mask is None:
								__lowercase 			=							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    _UpperCamelCase      :


			"""simple docstring"""






			__a  : Tuple			 =						OPTConfig
			__a  : int			 =						{}
			__a  : Dict			 =						'''gelu'''





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

							'''simple docstring'''


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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


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

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





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					int:

							'''simple docstring'''


							__lowercase 			=							TFOPTModel(config=lowerCAmelCase__						)
							__lowercase 			=							inputs_dict['''input_ids''']

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

							# first forward pass
							__lowercase 			=							model(lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__      ,   use_cache=lowerCAmelCase__						)

							__lowercase			,     __lowercase 			=							outputs.to_tuple()

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

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

							__lowercase 			=							model(lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__						)[0]
							__lowercase 			=							model(lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__      ,   past_key_values=lowerCAmelCase__						)[0]

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

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

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




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


			"""simple docstring"""






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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							__lowercase 			=							TFOPTModelTester(self						)
							__lowercase 			=							ConfigTester(self      ,   config_class=lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							self.config_tester.run_common_tests()





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


							__lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							def _get_word_embedding_weight(lowerCAmelCase__      ,   lowerCAmelCase__						):
											if hasattr(lowerCAmelCase__      ,   '''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(lowerCAmelCase__      ,   '''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
															__lowercase 			=							model_class(config=lowerCAmelCase__						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_input_embeddings()						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_output_embeddings()						)

															# reshape the embeddings
															model.resize_token_embeddings(lowerCAmelCase__						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_input_embeddings()						)
															__lowercase 			=							_get_word_embedding_weight(lowerCAmelCase__      ,   model.get_output_embeddings()						)

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

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

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

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

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





def 				UpperCAmelCase						(    lowercase							):







				"""simple docstring"""



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




@require_tf
class    _UpperCamelCase      (						unittest.TestCase ):


			"""simple docstring"""






			__a  : List[str]			 =						99





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


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

							'''simple docstring'''


							__lowercase 			=							TFOPTModel.from_pretrained('''facebook/opt-350m'''						)
							__lowercase 			=							_long_tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]						)
							__lowercase 			=							tf.not_equal(lowerCAmelCase__      ,   model.config.pad_token_id						)
							with tf.GradientTape():
											__lowercase 			=							model(input_ids=lowerCAmelCase__      ,   attention_mask=lowerCAmelCase__						).last_hidden_state
							__lowercase 			=							(1, 11, 5_12)
							self.assertEqual(output.shape      ,   lowerCAmelCase__						)
							__lowercase 			=							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]      ,   lowerCAmelCase__      ,   atol=4E-3						)						)

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




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


			"""simple docstring"""






			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


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

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

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




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


			"""simple docstring"""






			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					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        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


							__lowercase 			=							'''facebook/opt-125m'''

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

							__lowercase 			=							[]
							__lowercase 			=							GPTaTokenizer.from_pretrained(lowerCAmelCase__						)
							__lowercase 			=							TFOPTForCausalLM.from_pretrained(lowerCAmelCase__						)

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

											__lowercase 			=							model.generate(lowerCAmelCase__      ,   max_length=10						)

											__lowercase 			=							tokenizer.batch_decode(lowerCAmelCase__      ,   skip_special_tokens=lowerCAmelCase__						)
											predicted_outputs += generated_string

							self.assertListEqual(lowerCAmelCase__      ,   lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


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

							__lowercase 			=							GPTaTokenizer.from_pretrained(lowerCAmelCase__						)
							__lowercase 			=							TFOPTForCausalLM.from_pretrained(lowerCAmelCase__						)

							__lowercase 			=							'''left'''

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

							__lowercase 			=							tokenizer(lowerCAmelCase__      ,   return_tensors='''tf'''      ,   padding=lowerCAmelCase__						)
							__lowercase 			=							inputs['''input_ids''']

							__lowercase 			=							model.generate(input_ids=lowerCAmelCase__      ,   attention_mask=inputs['''attention_mask''']						)

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

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

							__lowercase 			=							tokenizer.batch_decode(lowerCAmelCase__      ,   skip_special_tokens=lowerCAmelCase__						)
							__lowercase 			=							tokenizer.decode(output_non_padded[0]      ,   skip_special_tokens=lowerCAmelCase__						)
							__lowercase 			=							tokenizer.decode(output_padded[0]      ,   skip_special_tokens=lowerCAmelCase__						)

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





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

							'''simple docstring'''


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

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

							__lowercase 			=							[]
							__lowercase 			=							GPTaTokenizer.from_pretrained(lowerCAmelCase__						)
							__lowercase 			=							TFOPTForCausalLM.from_pretrained(lowerCAmelCase__						)

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

											__lowercase 			=							model.generate(lowerCAmelCase__      ,   max_length=10						)

											__lowercase 			=							tokenizer.batch_decode(lowerCAmelCase__      ,   skip_special_tokens=lowerCAmelCase__						)
											predicted_outputs += generated_string

							self.assertListEqual(lowerCAmelCase__      ,   lowerCAmelCase__						)