



"""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      A__  :




	'''simple docstring'''





	SCREAMING_SNAKE_CASE        =      BlenderbotSmallConfig
	SCREAMING_SNAKE_CASE        =      {}
	SCREAMING_SNAKE_CASE        =      'gelu'

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

				"""simple docstring"""

				__lowerCAmelCase :    Optional[Any]				=			parent
				__lowerCAmelCase :    str				=			batch_size
				__lowerCAmelCase :    Optional[int]				=			seq_length
				__lowerCAmelCase :    Optional[Any]				=			is_training
				__lowerCAmelCase :    List[Any]				=			use_labels
				__lowerCAmelCase :    Any				=			vocab_size
				__lowerCAmelCase :    Union[str, Any]				=			hidden_size
				__lowerCAmelCase :    List[str]				=			num_hidden_layers
				__lowerCAmelCase :    List[str]				=			num_attention_heads
				__lowerCAmelCase :    int				=			intermediate_size

				__lowerCAmelCase :    List[str]				=			hidden_dropout_prob
				__lowerCAmelCase :    List[Any]				=			attention_probs_dropout_prob
				__lowerCAmelCase :    List[Any]				=			max_position_embeddings
				__lowerCAmelCase :    List[str]				=			eos_token_id
				__lowerCAmelCase :    List[Any]				=			pad_token_id
				__lowerCAmelCase :    Optional[Any]				=			bos_token_id

	def 				_SCREAMING_SNAKE_CASE  (	self:						int)							->			Optional[int]:

				"""simple docstring"""

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

				__lowerCAmelCase :    Dict				=			ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size)

				__lowerCAmelCase :    Union[str, 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			,     )
				__lowerCAmelCase :    Optional[int]				=			prepare_blenderbot_small_inputs_dict(_snake_case			,     _snake_case			,     _snake_case)
				return config, inputs_dict







	def 				_SCREAMING_SNAKE_CASE  (	self:						Dict			,     _SCREAMING_SNAKE_CASE:						Optional[int]			,     _SCREAMING_SNAKE_CASE:						Union[str, Any])							->			Any:

				"""simple docstring"""

				__lowerCAmelCase :    str				=			TFBlenderbotSmallModel(config=_snake_case).get_decoder()
				__lowerCAmelCase :    List[Any]				=			inputs_dict["input_ids"]

				__lowerCAmelCase :    List[str]				=			input_ids[:1, :]
				__lowerCAmelCase :    List[Any]				=			inputs_dict["attention_mask"][:1, :]
				__lowerCAmelCase :    Optional[Any]				=			inputs_dict["head_mask"]
				__lowerCAmelCase :    str				=			1

				# first forward pass
				__lowerCAmelCase :    List[Any]				=			model(_snake_case			,     attention_mask=_snake_case			,     head_mask=_snake_case			,     use_cache=_snake_case)

				__lowerCAmelCase		,      __lowerCAmelCase :    Optional[int]				=			outputs.to_tuple()

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

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

				__lowerCAmelCase :    Tuple				=			model(_snake_case			,     attention_mask=_snake_case)[0]
				__lowerCAmelCase :    Optional[Any]				=			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
				__lowerCAmelCase :    Any				=			int(ids_tensor((1,)			,     output_from_past.shape[-1]))
				__lowerCAmelCase :    Optional[Any]				=			output_from_no_past[:, -3:, random_slice_idx]
				__lowerCAmelCase :    Union[str, Any]				=			output_from_past[:, :, random_slice_idx]

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






def      _lowercase							(    __snake_case   ,__snake_case   ,__snake_case   ,__snake_case=None   ,__snake_case=None   ,__snake_case=None   ,__snake_case=None   ,__snake_case=None   ,)		->  Optional[int]:
			if attention_mask is None:
						__lowerCAmelCase :    int				=			tf.cast(tf.math.not_equal(_UpperCAmelCase   ,config.pad_token_id      )   ,tf.inta      )
			if decoder_attention_mask is None:
						__lowerCAmelCase :    str				=			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:
						__lowerCAmelCase :    Dict				=			tf.ones((config.encoder_layers, config.encoder_attention_heads)      )
			if decoder_head_mask is None:
						__lowerCAmelCase :    Tuple				=			tf.ones((config.decoder_layers, config.decoder_attention_heads)      )
			if cross_attn_head_mask is None:
						__lowerCAmelCase :    Optional[int]				=			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      A__  (    a__    ,						a__    ,						unittest.TestCase				):




	'''simple docstring'''





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

	def 				_SCREAMING_SNAKE_CASE  (	self:						Union[str, Any])							->			Dict:

				"""simple docstring"""

				__lowerCAmelCase :    List[Any]				=			TFBlenderbotSmallModelTester(self)
				__lowerCAmelCase :    Dict				=			ConfigTester(self			,     config_class=_snake_case)

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

				"""simple docstring"""

				self.config_tester.run_common_tests()







	def 				_SCREAMING_SNAKE_CASE  (	self:						int)							->			Optional[Any]:

				"""simple docstring"""

				__lowerCAmelCase :    int				=			self.model_tester.prepare_config_and_inputs_for_common()
				self.model_tester.check_decoder_model_past_large_inputs(*_snake_case)






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




	'''simple docstring'''





	SCREAMING_SNAKE_CASE        =      [
	    '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?'
	]
	SCREAMING_SNAKE_CASE        =      'facebook/blenderbot_small-90M'

	@cached_property
	def 				_SCREAMING_SNAKE_CASE  (	self:						Dict)							->			Optional[Any]:

				"""simple docstring"""

				return BlenderbotSmallTokenizer.from_pretrained("facebook/blenderbot-90M")

	@cached_property
	def 				_SCREAMING_SNAKE_CASE  (	self:						Dict)							->			str:

				"""simple docstring"""

				__lowerCAmelCase :    Any				=			TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name)
				return model







	@slow
	def 				_SCREAMING_SNAKE_CASE  (	self:						Tuple)							->			int:

				"""simple docstring"""

				__lowerCAmelCase :    Union[str, Any]				=			self.tokenizer(self.src_text			,     return_tensors="tf")
				__lowerCAmelCase :    List[Any]				=			self.model.generate(
				    model_inputs.input_ids			,     attention_mask=model_inputs.attention_mask			,     num_beams=2			,     use_cache=_snake_case			,     )
				__lowerCAmelCase :    Optional[int]				=			self.tokenizer.batch_decode(generated_ids.numpy()			,     skip_special_tokens=_snake_case)[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"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCamelCase     :						Optional[Any]						       =  logging.get_logger(__name__)

__UpperCamelCase     :						List[Any]						       =  {
    # See all MEGATRON_BERT models at https://huggingface.co/models?filter=bert
}







class       a							(   a__  ):
 snake_case__             =       '''megatron-bert'''



 def __init__(     self				,       _snake_case=2_90_56				,       _snake_case=10_24				,       _snake_case=24				,       _snake_case=16				,       _snake_case=40_96				,       _snake_case="gelu"				,       _snake_case=0.1				,       _snake_case=0.1				,       _snake_case=5_12				,       _snake_case=2				,       _snake_case=0.02				,       _snake_case=1E-12				,       _snake_case=0				,       _snake_case="absolute"				,       _snake_case=True				,       **_snake_case				,       ):







  """simple docstring"""






  super().__init__(pad_token_id=_snake_case				,       **_snake_case     )

  lowerCAmelCase    				= vocab_size
  lowerCAmelCase    				= hidden_size
  lowerCAmelCase    				= num_hidden_layers
  lowerCAmelCase    				= num_attention_heads
  lowerCAmelCase    				= hidden_act
  lowerCAmelCase    				= intermediate_size
  lowerCAmelCase    				= hidden_dropout_prob
  lowerCAmelCase    				= attention_probs_dropout_prob
  lowerCAmelCase    				= max_position_embeddings
  lowerCAmelCase    				= type_vocab_size
  lowerCAmelCase    				= initializer_range
  lowerCAmelCase    				= layer_norm_eps
  lowerCAmelCase    				= position_embedding_type
  lowerCAmelCase    				= use_cache





