





"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

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 TFAutoModelForSeqaSeqLM, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel




@require_tf
class 				__lowercase			:







					'''simple docstring'''




					__lowerCAmelCase  =  BlenderbotSmallConfig
					__lowerCAmelCase  =  {}
					__lowerCAmelCase  =  '''gelu'''







					def __init__(						self	,			_UpperCAmelCase	,			_UpperCAmelCase=13	,			_UpperCAmelCase=7	,			_UpperCAmelCase=True	,			_UpperCAmelCase=False	,			_UpperCAmelCase=99	,			_UpperCAmelCase=32	,			_UpperCAmelCase=2	,			_UpperCAmelCase=4	,			_UpperCAmelCase=37	,			_UpperCAmelCase=0.1	,			_UpperCAmelCase=0.1	,			_UpperCAmelCase=20	,			_UpperCAmelCase=2	,			_UpperCAmelCase=1	,			_UpperCAmelCase=0	,			):
									__a :						Optional[Any]			       =  parent
									__a :						Optional[Any]			       =  batch_size
									__a :						int			       =  seq_length
									__a :						List[Any]			       =  is_training
									__a :						Optional[Any]			       =  use_labels
									__a :						Optional[int]			       =  vocab_size
									__a :						Optional[Any]			       =  hidden_size
									__a :						Dict			       =  num_hidden_layers
									__a :						Optional[Any]			       =  num_attention_heads
									__a :						List[str]			       =  intermediate_size

									__a :						List[Any]			       =  hidden_dropout_prob
									__a :						Optional[int]			       =  attention_probs_dropout_prob
									__a :						Union[str, Any]			       =  max_position_embeddings
									__a :						List[Any]			       =  eos_token_id
									__a :						Optional[Any]			       =  pad_token_id
									__a :						Dict			       =  bos_token_id







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

									__a :						Union[str, Any]			       =  ids_tensor([self.batch_size, self.seq_length]	,			self.vocab_size     )

									__a :						Optional[Any]			       =  self.config_cls(
									    vocab_size=self.vocab_size	,			d_model=self.hidden_size	,			encoder_layers=self.num_hidden_layers	,			decoder_layers=self.num_hidden_layers	,			encoder_attention_heads=self.num_attention_heads	,			decoder_attention_heads=self.num_attention_heads	,			encoder_ffn_dim=self.intermediate_size	,			decoder_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_ids=[2]	,			bos_token_id=self.bos_token_id	,			pad_token_id=self.pad_token_id	,			decoder_start_token_id=self.pad_token_id	,			**self.config_updates	,			)
									__a :						Optional[Any]			       =  prepare_blenderbot_small_inputs_dict(_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     )
									return config, inputs_dict







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						List[str]			       =  TFBlenderbotSmallModel(config=_UpperCAmelCase     ).get_decoder()
									__a :						Optional[Any]			       =  inputs_dict['''input_ids''']

									__a :						str			       =  input_ids[:1, :]
									__a :						str			       =  inputs_dict['''attention_mask'''][:1, :]
									__a :						Union[str, Any]			       =  inputs_dict['''head_mask''']
									__a :						str			       =  1

									# first forward pass
									__a :						Any			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			head_mask=_UpperCAmelCase	,			use_cache=_UpperCAmelCase     )

									__a       ,						__a :						Any			       =  outputs.to_tuple()

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

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

									__a :						int			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase     )[0]
									__a :						Union[str, Any]			       =  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
									__a :						List[str]			       =  int(ids_tensor((1,)	,			output_from_past.shape[-1]     )     )
									__a :						Any			       =  output_from_no_past[:, -3:, random_slice_idx]
									__a :						Dict			       =  output_from_past[:, :, random_slice_idx]

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






def     __A      (			a_						:List[Any]   ,       a_						:str   ,       a_						:Any   ,       a_						:Dict=None   ,       a_						:List[Any]=None   ,       a_						:Any=None   ,       a_						:Union[str, Any]=None   ,       a_						:Tuple=None   ,       )		->		int:
				if attention_mask is None:
								__a :						Optional[int]			       =  tf.cast(tf.math.not_equal(a_   ,       config.pad_token_id)   ,       tf.inta)
				if decoder_attention_mask is None:
								__a :						Union[str, Any]			       =  tf.concat(
								    [
								        tf.ones(decoder_input_ids[:, :1].shape   ,       dtype=tf.inta),
								        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]   ,       config.pad_token_id)   ,       tf.inta),
								    ]   ,       axis=-1   ,       )
				if head_mask is None:
								__a :						Tuple			       =  tf.ones((config.encoder_layers, config.encoder_attention_heads))
				if decoder_head_mask is None:
								__a :						Any			       =  tf.ones((config.decoder_layers, config.decoder_attention_heads))
				if cross_attn_head_mask is None:
								__a :						List[str]			       =  tf.ones((config.decoder_layers, config.decoder_attention_heads))
				return {
				    "input_ids": input_ids,
				    "decoder_input_ids": decoder_input_ids,
				    "attention_mask": attention_mask,
				    "decoder_attention_mask": decoder_attention_mask,
				    "head_mask": head_mask,
				    "decoder_head_mask": decoder_head_mask,
				    "cross_attn_head_mask": cross_attn_head_mask,
				}




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







					'''simple docstring'''




					__lowerCAmelCase  =  (
					    (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
					)
					__lowerCAmelCase  =  (TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
					__lowerCAmelCase  =  (
					    {
					        '''conversational''': TFBlenderbotSmallForConditionalGeneration,
					        '''feature-extraction''': TFBlenderbotSmallModel,
					        '''summarization''': TFBlenderbotSmallForConditionalGeneration,
					        '''text2text-generation''': TFBlenderbotSmallForConditionalGeneration,
					        '''translation''': TFBlenderbotSmallForConditionalGeneration,
					    }
					    if is_tf_available()
					    else {}
					)
					__lowerCAmelCase  =  True
					__lowerCAmelCase  =  False
					__lowerCAmelCase  =  False







					def  _lowerCamelCase		(						self     ):
									__a :						Any			       =  TFBlenderbotSmallModelTester(self     )
									__a :						List[Any]			       =  ConfigTester(self	,			config_class=_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									self.config_tester.run_common_tests()







					def  _lowerCamelCase		(						self     ):
									__a :						Any			       =  self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase     )






@require_tokenizers
@require_tf
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  [
					    '''Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like '''
					    '''  i\'m going to throw up.\nand why is that?'''
					]
					__lowerCAmelCase  =  '''facebook/blenderbot_small-90M'''







					@cached_property
					def  _lowerCamelCase		(						self     ):
									# use "old" tokenizer here because of bug when downloading new tokenizer
									return BlenderbotSmallTokenizer.from_pretrained('''facebook/blenderbot-90M'''     )







					@cached_property
					def  _lowerCamelCase		(						self     ):
									__a :						int			       =  TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name     )
									return model







					@slow
					def  _lowerCamelCase		(						self     ):
									__a :						int			       =  self.tokenizer(self.src_text	,			return_tensors='''tf'''     )
									__a :						Tuple			       =  self.model.generate(
									    model_inputs.input_ids	,			attention_mask=model_inputs.attention_mask	,			num_beams=2	,			use_cache=_UpperCAmelCase	,			)
									__a :						str			       =  self.tokenizer.batch_decode(generated_ids.numpy()	,			skip_special_tokens=_UpperCAmelCase     )[0]
									assert generated_words in (
									    "i don't know. i just feel like i'm going to throw up. it's not fun.",
									    "i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
									    "i'm not sure. i just feel like i've been in a bad situation.",
									)






"""simple docstring"""






import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
		import tensorflow as tf

if is_tensorflow_text_available():
		from transformers.models.bert import TFBertTokenizer


A 			=  ['''bert-base-uncased''', '''bert-base-cased''']
A 			=  '''hf-internal-testing/tiny-bert-tf-only'''

if is_tf_available():




		class 				__lowercase			(			tf.keras.Model							):







							'''simple docstring'''




							def __init__(						self	,			_UpperCAmelCase     ):
											super().__init__()
											__a :						Any			       =  tokenizer
											__a :						Optional[Any]			       =  AutoConfig.from_pretrained(_UpperCAmelCase     )
											__a :						str			       =  TFAutoModel.from_config(_UpperCAmelCase     )







							def  _lowerCamelCase		(						self	,			_UpperCAmelCase     ):
											__a :						Any			       =  self.tokenizer(_UpperCAmelCase     )
											__a :						int			       =  self.bert(**_UpperCAmelCase     )
											return out["pooler_output"]




@require_tf
@require_tensorflow_text
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					def  _lowerCamelCase		(						self     ):
									super().setUp()

									__a :						Any			       =  [
									    BertTokenizer.from_pretrained(_UpperCAmelCase     ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
									]  # repeat for when fast_bert_tokenizer=false
									__a :						Union[str, Any]			       =  [TFBertTokenizer.from_pretrained(_UpperCAmelCase     ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
									    TFBertTokenizer.from_pretrained(_UpperCAmelCase	,			use_fast_bert_tokenizer=_UpperCAmelCase     )
									    for checkpoint in TOKENIZER_CHECKPOINTS
									]
									assert len(self.tokenizers     ) == len(self.tf_tokenizers     )

									__a :						Tuple			       =  [
									    '''This is a straightforward English test sentence.''',
									    '''This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.''',
									    '''Now we\'re going to add some Chinese: 一 二 三 一二三''',
									    '''And some much more rare Chinese: 齉 堃 齉堃''',
									    '''Je vais aussi écrire en français pour tester les accents''',
									    '''Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ''',
									]
									__a :						Any			       =  list(zip(self.test_sentences	,			self.test_sentences[::-1]     )     )







					def  _lowerCamelCase		(						self     ):
									for tokenizer, tf_tokenizer in zip(self.tokenizers	,			self.tf_tokenizers     ):
													for test_inputs in (self.test_sentences, self.paired_sentences):
																	__a :						List[Any]			       =  tokenizer(_UpperCAmelCase	,			return_tensors='''tf'''	,			padding='''longest'''     )
																	__a :						List[str]			       =  tf_tokenizer(_UpperCAmelCase     )

																	for key in python_outputs.keys():
																					self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape     )     )
																					self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]	,			tf.intaa     ) == tf_outputs[key]     )     )







					@slow
					def  _lowerCamelCase		(						self     ):
									for tf_tokenizer in self.tf_tokenizers:
													__a :						Dict			       =  tf_tokenizer(self.paired_sentences     )
													__a :						str			       =  tf_tokenizer(
													    text=[sentence[0] for sentence in self.paired_sentences]	,			text_pair=[sentence[1] for sentence in self.paired_sentences]	,			)
													for key in merged_outputs.keys():
																	self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]	,			tf.intaa     ) == separated_outputs[key]     )     )







					@slow
					def  _lowerCamelCase		(						self     ):
									for tf_tokenizer in self.tf_tokenizers:
													__a :						Tuple			       =  tf.function(_UpperCAmelCase     )
													for test_inputs in (self.test_sentences, self.paired_sentences):
																	__a :						List[str]			       =  tf.constant(_UpperCAmelCase     )
																	__a :						Tuple			       =  compiled_tokenizer(_UpperCAmelCase     )
																	__a :						Union[str, Any]			       =  tf_tokenizer(_UpperCAmelCase     )

																	for key in eager_outputs.keys():
																					self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]     )     )







					@slow
					def  _lowerCamelCase		(						self     ):
									for tf_tokenizer in self.tf_tokenizers:
													__a :						Dict			       =  ModelToSave(tokenizer=_UpperCAmelCase     )
													__a :						Tuple			       =  tf.convert_to_tensor(self.test_sentences     )
													__a :						List[str]			       =  model(_UpperCAmelCase     )  # Build model with some sample inputs
													with TemporaryDirectory() as tempdir:
																	__a :						Tuple			       =  Path(_UpperCAmelCase     ) / '''saved.model'''
																	model.save(_UpperCAmelCase     )
																	__a :						Tuple			       =  tf.keras.models.load_model(_UpperCAmelCase     )
													__a :						int			       =  loaded_model(_UpperCAmelCase     )
													# We may see small differences because the loaded model is compiled, so we need an epsilon for the test
													self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output     )     )	,			1e-5     )