



"""simple docstring"""





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

		'''simple docstring'''


		if attention_mask is None:
				_UpperCAmelCase							 =		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 			lowercase__			:
							'''simple docstring'''







							_UpperCAmelCase      				=					OPTConfig
							_UpperCAmelCase      				=					{}
							_UpperCAmelCase      				=					'''gelu'''






							def __init__(  self	,       snake_case	,       snake_case=13	,       snake_case=7	,       snake_case=True	,       snake_case=False	,       snake_case=99	,       snake_case=16	,       snake_case=2	,       snake_case=4	,       snake_case=4	,       snake_case="gelu"	,       snake_case=0.1	,       snake_case=0.1	,       snake_case=20	,       snake_case=2	,       snake_case=1	,       snake_case=0	,       snake_case=16	,       snake_case=16	,       )			->							Optional[int]:
									_UpperCAmelCase							 =		parent
									_UpperCAmelCase							 =		batch_size
									_UpperCAmelCase							 =		seq_length
									_UpperCAmelCase							 =		is_training
									_UpperCAmelCase							 =		use_labels
									_UpperCAmelCase							 =		vocab_size
									_UpperCAmelCase							 =		hidden_size
									_UpperCAmelCase							 =		num_hidden_layers
									_UpperCAmelCase							 =		num_attention_heads
									_UpperCAmelCase							 =		intermediate_size
									_UpperCAmelCase							 =		hidden_act
									_UpperCAmelCase							 =		hidden_dropout_prob
									_UpperCAmelCase							 =		attention_probs_dropout_prob
									_UpperCAmelCase							 =		max_position_embeddings
									_UpperCAmelCase							 =		eos_token_id
									_UpperCAmelCase							 =		pad_token_id
									_UpperCAmelCase							 =		bos_token_id
									_UpperCAmelCase							 =		embed_dim
									_UpperCAmelCase							 =		word_embed_proj_dim
									_UpperCAmelCase							 =		False






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

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






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Optional[Any]:
									_UpperCAmelCase							 =		TFOPTModel(config=snake_case						)
									_UpperCAmelCase							 =		inputs_dict['input_ids']

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

									# first forward pass
									_UpperCAmelCase							 =		model(snake_case	,       attention_mask=snake_case	,       use_cache=snake_case						)

									_UpperCAmelCase ,					_UpperCAmelCase							 =		outputs.to_tuple()

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

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

									_UpperCAmelCase							 =		model(snake_case	,       attention_mask=snake_case						)[0]
									_UpperCAmelCase							 =		model(snake_case	,       attention_mask=snake_case	,       past_key_values=snake_case						)[0]

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

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

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







@require_tf
class 			lowercase__			(      A,					A,					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        lowerCamelCase_   (  self						)			->							Dict:
									_UpperCAmelCase							 =		TFOPTModelTester(self						)
									_UpperCAmelCase							 =		ConfigTester(self	,       config_class=snake_case						)






							def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									self.config_tester.run_common_tests()






							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									_UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.check_decoder_model_past_large_inputs(*snake_case						)






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									_UpperCAmelCase ,					_UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs_for_common()

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

													# reshape the embeddings
													model.resize_token_embeddings(snake_case						)
													_UpperCAmelCase							 =		_get_word_embedding_weight(snake_case	,       model.get_input_embeddings()						)
													_UpperCAmelCase							 =		_get_word_embedding_weight(snake_case	,       model.get_output_embeddings()						)

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

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

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

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

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







def 	UpperCAmelCase     (		A	:						Any       ):

		'''simple docstring'''


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




@require_tf
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					99






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







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

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







@require_tf
@slow
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							Any:
									super().setUp()
									_UpperCAmelCase							 =		'facebook/opt-350m'






							def        lowerCamelCase_   (  self						)			->							Tuple:
									_UpperCAmelCase							 =		TFOPTForCausalLM.from_pretrained(self.path_model						)
									_UpperCAmelCase							 =		GPTaTokenizer.from_pretrained(self.path_model						)

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

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







@require_tf
@slow
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							@property
							def        lowerCamelCase_   (  self						)			->							str:
									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						)			->							Optional[Any]:
									_UpperCAmelCase							 =		'facebook/opt-125m'

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

									_UpperCAmelCase							 =		[]
									_UpperCAmelCase							 =		GPTaTokenizer.from_pretrained(snake_case						)
									_UpperCAmelCase							 =		TFOPTForCausalLM.from_pretrained(snake_case						)

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

											_UpperCAmelCase							 =		model.generate(snake_case	,       max_length=10						)

											_UpperCAmelCase							 =		tokenizer.batch_decode(snake_case	,       skip_special_tokens=snake_case						)
											predicted_outputs += generated_string

									self.assertListEqual(snake_case	,       snake_case						)






							def        lowerCamelCase_   (  self						)			->							Tuple:
									_UpperCAmelCase							 =		'facebook/opt-350m'

									_UpperCAmelCase							 =		GPTaTokenizer.from_pretrained(snake_case						)
									_UpperCAmelCase							 =		TFOPTForCausalLM.from_pretrained(snake_case						)

									_UpperCAmelCase							 =		'left'

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

									_UpperCAmelCase							 =		tokenizer(snake_case	,       return_tensors='tf'	,       padding=snake_case						)
									_UpperCAmelCase							 =		inputs['input_ids']

									_UpperCAmelCase							 =		model.generate(input_ids=snake_case	,       attention_mask=inputs['attention_mask']						)

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

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

									_UpperCAmelCase							 =		tokenizer.batch_decode(snake_case	,       skip_special_tokens=snake_case						)
									_UpperCAmelCase							 =		tokenizer.decode(output_non_padded[0]	,       skip_special_tokens=snake_case						)
									_UpperCAmelCase							 =		tokenizer.decode(output_padded[0]	,       skip_special_tokens=snake_case						)

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






							def        lowerCamelCase_   (  self						)			->							Tuple:
									_UpperCAmelCase							 =		'facebook/opt-350m'

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

									_UpperCAmelCase							 =		[]
									_UpperCAmelCase							 =		GPTaTokenizer.from_pretrained(snake_case						)
									_UpperCAmelCase							 =		TFOPTForCausalLM.from_pretrained(snake_case						)

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

											_UpperCAmelCase							 =		model.generate(snake_case	,       max_length=10						)

											_UpperCAmelCase							 =		tokenizer.batch_decode(snake_case	,       skip_special_tokens=snake_case						)
											predicted_outputs += generated_string

									self.assertListEqual(snake_case	,       snake_case						)







"""simple docstring"""





from typing import TYPE_CHECKING

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


lowercase  							=					{
    '''configuration_mvp''': ['''MVP_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MvpConfig''', '''MvpOnnxConfig'''],
    '''tokenization_mvp''': ['''MvpTokenizer'''],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					['''MvpTokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					[
					    '''MVP_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''MvpForCausalLM''',
					    '''MvpForConditionalGeneration''',
					    '''MvpForQuestionAnswering''',
					    '''MvpForSequenceClassification''',
					    '''MvpModel''',
					    '''MvpPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig
					from .tokenization_mvp import MvpTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_mvp_fast import MvpTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_mvp import (
										    MVP_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MvpForCausalLM,
										    MvpForConditionalGeneration,
										    MvpForQuestionAnswering,
										    MvpForSequenceClassification,
										    MvpModel,
										    MvpPreTrainedModel,
										)

else:
					import sys

					lowercase  							=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


