






'''simple docstring'''





import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    NystromformerForMaskedLM,
	    NystromformerForMultipleChoice,
	    NystromformerForQuestionAnswering,
	    NystromformerForSequenceClassification,
	    NystromformerForTokenClassification,
	    NystromformerModel,
	)
	from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST
class 				lowercase       :


				'''simple docstring'''

				def __init__(					self     :     List[str]				,     __lowerCamelCase     :     Dict				,     __lowerCamelCase     :     List[Any]=13				,     __lowerCamelCase     :     Any=7				,     __lowerCamelCase     :     Tuple=True				,     __lowerCamelCase     :     List[str]=True				,     __lowerCamelCase     :     List[str]=True				,     __lowerCamelCase     :     int=True				,     __lowerCamelCase     :     Tuple=99				,     __lowerCamelCase     :     str=32				,     __lowerCamelCase     :     Union[str, Any]=5				,     __lowerCamelCase     :     str=4				,     __lowerCamelCase     :     List[Any]=37				,     __lowerCamelCase     :     Optional[int]="gelu"				,     __lowerCamelCase     :     int=0.1				,     __lowerCamelCase     :     Dict=0.1				,     __lowerCamelCase     :     List[str]=512				,     __lowerCamelCase     :     int=16				,     __lowerCamelCase     :     Tuple=2				,     __lowerCamelCase     :     Dict=0.0_2				,     __lowerCamelCase     :     Optional[Any]=3				,     __lowerCamelCase     :     int=4				,     __lowerCamelCase     :     Optional[Any]=None				,     )							->							str:

					'''simple docstring'''




					lowerCamelCase__  =     parent
					lowerCamelCase__  =     batch_size
					lowerCamelCase__  =     seq_length
					lowerCamelCase__  =     is_training
					lowerCamelCase__  =     use_input_mask
					lowerCamelCase__  =     use_token_type_ids
					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__  =     type_vocab_size
					lowerCamelCase__  =     type_sequence_label_size
					lowerCamelCase__  =     initializer_range
					lowerCamelCase__  =     num_labels
					lowerCamelCase__  =     num_choices
					lowerCamelCase__  =     scope

				def    a__				(					self     :     Dict     )							->							Dict:

					'''simple docstring'''




					lowerCamelCase__  =     ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size     )

					lowerCamelCase__  =     None
					if self.use_input_mask:
						lowerCamelCase__  =     random_attention_mask([self.batch_size, self.seq_length]     )

					lowerCamelCase__  =     None
					if self.use_token_type_ids:
						lowerCamelCase__  =     ids_tensor([self.batch_size, self.seq_length]				,     self.type_vocab_size     )

					lowerCamelCase__  =     None
					lowerCamelCase__  =     None
					lowerCamelCase__  =     None
					if self.use_labels:
						lowerCamelCase__  =     ids_tensor([self.batch_size]				,     self.type_sequence_label_size     )
						lowerCamelCase__  =     ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels     )
						lowerCamelCase__  =     ids_tensor([self.batch_size]				,     self.num_choices     )

					lowerCamelCase__  =     self.get_config()

					return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

				def    a__				(					self     :     List[Any]     )							->							Dict:

					'''simple docstring'''




					return NystromformerConfig(
					    vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     is_decoder=__lowerCamelCase				,     initializer_range=self.initializer_range				,     )

				def    a__				(					self     :     Optional[int]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     int				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     str				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     str     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     NystromformerModel(config=__lowerCamelCase     )
					model.to(__lowerCamelCase     )
					model.eval()
					lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     token_type_ids=__lowerCamelCase     )
					lowerCamelCase__  =     model(__lowerCamelCase				,     token_type_ids=__lowerCamelCase     )
					lowerCamelCase__  =     model(__lowerCamelCase     )
					self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)     )

				def    a__				(					self     :     Optional[Any]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     Dict				,     __lowerCamelCase     :     List[str]				,     __lowerCamelCase     :     int				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     Union[str, Any]     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     NystromformerForMaskedLM(config=__lowerCamelCase     )
					model.to(__lowerCamelCase     )
					model.eval()
					lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     token_type_ids=__lowerCamelCase				,     labels=__lowerCamelCase     )
					self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)     )

				def    a__				(					self     :     List[str]				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     Dict				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     int     )							->							Any:

					'''simple docstring'''




					lowerCamelCase__  =     NystromformerForQuestionAnswering(config=__lowerCamelCase     )
					model.to(__lowerCamelCase     )
					model.eval()
					lowerCamelCase__  =     model(
					    __lowerCamelCase				,     attention_mask=__lowerCamelCase				,     token_type_ids=__lowerCamelCase				,     start_positions=__lowerCamelCase				,     end_positions=__lowerCamelCase				,     )
					self.parent.assertEqual(result.start_logits.shape				,     (self.batch_size, self.seq_length)     )
					self.parent.assertEqual(result.end_logits.shape				,     (self.batch_size, self.seq_length)     )

				def    a__				(					self     :     int				,     __lowerCamelCase     :     Optional[Any]				,     __lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     Dict				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     Any				,     __lowerCamelCase     :     List[str]     )							->							Optional[int]:

					'''simple docstring'''




					lowerCamelCase__  =     self.num_labels
					lowerCamelCase__  =     NystromformerForSequenceClassification(__lowerCamelCase     )
					model.to(__lowerCamelCase     )
					model.eval()
					lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     token_type_ids=__lowerCamelCase				,     labels=__lowerCamelCase     )
					self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)     )

				def    a__				(					self     :     str				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Any				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Optional[Any]				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     int     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     self.num_labels
					lowerCamelCase__  =     NystromformerForTokenClassification(config=__lowerCamelCase     )
					model.to(__lowerCamelCase     )
					model.eval()
					lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     token_type_ids=__lowerCamelCase				,     labels=__lowerCamelCase     )
					self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)     )

				def    a__				(					self     :     Any				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Any				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     str				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     List[str]				,     __lowerCamelCase     :     int     )							->							Any:

					'''simple docstring'''




					lowerCamelCase__  =     self.num_choices
					lowerCamelCase__  =     NystromformerForMultipleChoice(config=__lowerCamelCase     )
					model.to(__lowerCamelCase     )
					model.eval()
					lowerCamelCase__  =     input_ids.unsqueeze(1     ).expand(-1				,     self.num_choices				,     -1     ).contiguous()
					lowerCamelCase__  =     token_type_ids.unsqueeze(1     ).expand(-1				,     self.num_choices				,     -1     ).contiguous()
					lowerCamelCase__  =     input_mask.unsqueeze(1     ).expand(-1				,     self.num_choices				,     -1     ).contiguous()
					lowerCamelCase__  =     model(
					    __lowerCamelCase				,     attention_mask=__lowerCamelCase				,     token_type_ids=__lowerCamelCase				,     labels=__lowerCamelCase				,     )
					self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_choices)     )




				def    a__				(					self     :     int     )							->							List[str]:

					'''simple docstring'''




					lowerCamelCase__  =     self.prepare_config_and_inputs()
					(
					    (
					    lowerCamelCase__	
					)  ,	(
					    lowerCamelCase__	
					)  ,	(
					    lowerCamelCase__	
					)  ,	(
					    lowerCamelCase__	
					)  ,	(
					    lowerCamelCase__	
					)  ,	(
					    lowerCamelCase__	
					)  ,	(
					    lowerCamelCase__	
					)  ,		
					)  =     config_and_inputs
					lowerCamelCase__  =     {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
					return config, inputs_dict
@require_torch
class 				lowercase       (							_lowerCamelCase ,       _lowerCamelCase ,       unittest.TestCase      ):


				'''simple docstring'''

				lowerCAmelCase__      				=							(
				    (
				        NystromformerModel,
				        NystromformerForMaskedLM,
				        NystromformerForMultipleChoice,
				        NystromformerForQuestionAnswering,
				        NystromformerForSequenceClassification,
				        NystromformerForTokenClassification,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCAmelCase__      				=							(
				    {
				        "feature-extraction": NystromformerModel,
				        "fill-mask": NystromformerForMaskedLM,
				        "question-answering": NystromformerForQuestionAnswering,
				        "text-classification": NystromformerForSequenceClassification,
				        "token-classification": NystromformerForTokenClassification,
				        "zero-shot": NystromformerForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False

				def    a__				(					self     :     Optional[int]     )							->							Tuple:

					'''simple docstring'''




					lowerCamelCase__  =     NystromformerModelTester(self     )
					lowerCamelCase__  =     ConfigTester(self				,     config_class=__lowerCamelCase				,     hidden_size=37     )

				def    a__				(					self     :     Optional[int]     )							->							List[str]:

					'''simple docstring'''




					self.config_tester.run_common_tests()

				def    a__				(					self     :     List[Any]     )							->							Dict:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__lowerCamelCase     )

				def    a__				(					self     :     int     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
						lowerCamelCase__  =     type
						self.model_tester.create_and_check_model(*__lowerCamelCase     )

				def    a__				(					self     :     List[Any]     )							->							Optional[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase     )

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

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_multiple_choice(*__lowerCamelCase     )

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

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase     )

				def    a__				(					self     :     List[Any]     )							->							List[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase     )

				def    a__				(					self     :     Dict     )							->							List[str]:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase     )




				@slow
				def    a__				(					self     :     List[str]     )							->							int:

					'''simple docstring'''




					for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowerCamelCase__  =     NystromformerModel.from_pretrained(__lowerCamelCase     )
						self.assertIsNotNone(__lowerCamelCase     )
@require_torch
class 				lowercase       (							unittest.TestCase      ):


				'''simple docstring'''

				@slow
				def    a__				(					self     :     Tuple     )							->							Tuple:

					'''simple docstring'''




					lowerCamelCase__  =     NystromformerModel.from_pretrained("uw-madison/nystromformer-512"     )
					lowerCamelCase__  =     torch.tensor([[0, 1, 2, 3, 4, 5]]     )

					with torch.no_grad():
						lowerCamelCase__  =     model(__lowerCamelCase     )[0]

					lowerCamelCase__  =     torch.Size((1, 6, 768)     )
					self.assertEqual(output.shape				,     __lowerCamelCase     )

					lowerCamelCase__  =     torch.tensor(
					    [[[-0.4_5_3_2, -0.0_9_3_6, 0.5_1_3_7], [-0.2_6_7_6, 0.0_6_2_8, 0.6_1_8_6], [-0.3_6_2_9, -0.1_7_2_6, 0.4_7_1_6]]]     )

					self.assertTrue(torch.allclose(output[:, :3, :3]				,     __lowerCamelCase				,     atol=1E-4     )     )




				@slow
				def    a__				(					self     :     str     )							->							str:

					'''simple docstring'''




					lowerCamelCase__  =     "the [MASK] of Belgium is Brussels"

					lowerCamelCase__  =     AutoTokenizer.from_pretrained("uw-madison/nystromformer-512"     )
					lowerCamelCase__  =     NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512"     )

					lowerCamelCase__  =     tokenizer(__lowerCamelCase				,     return_tensors="pt"     )

					with torch.no_grad():
						lowerCamelCase__  =     model(encoding.input_ids     ).logits

					lowerCamelCase__  =     token_logits[:, 2, :].argmax(-1     )[0]

					self.assertEqual(tokenizer.decode(__lowerCamelCase     )				,     "capital"     )









'''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     :     List[Any]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     str=13				,     __lowerCamelCase     :     List[str]=7				,     __lowerCamelCase     :     Dict=True				,     __lowerCamelCase     :     Any=False				,     __lowerCamelCase     :     Union[str, Any]=99				,     __lowerCamelCase     :     Optional[int]=32				,     __lowerCamelCase     :     Optional[int]=2				,     __lowerCamelCase     :     List[str]=4				,     __lowerCamelCase     :     Union[str, Any]=37				,     __lowerCamelCase     :     Tuple=0.1				,     __lowerCamelCase     :     List[str]=0.1				,     __lowerCamelCase     :     int=20				,     __lowerCamelCase     :     Optional[Any]=2				,     __lowerCamelCase     :     List[str]=1				,     __lowerCamelCase     :     Union[str, Any]=0				,     )							->							str:

     '''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_dropout_prob
     lowerCamelCase__  =     attention_probs_dropout_prob
     lowerCamelCase__  =     max_position_embeddings
     lowerCamelCase__  =     eos_token_id
     lowerCamelCase__  =     pad_token_id
     lowerCamelCase__  =     bos_token_id

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

     '''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__  =     ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size     )

     lowerCamelCase__  =     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__  =     prepare_blenderbot_small_inputs_dict(__lowerCamelCase				,     __lowerCamelCase				,     __lowerCamelCase     )
     return config, inputs_dict




    def    a__				(					self     :     int				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Optional[Any]     )							->							Tuple:

     '''simple docstring'''




     lowerCamelCase__  =     TFBlenderbotSmallModel(config=__lowerCamelCase     ).get_decoder()
     lowerCamelCase__  =     inputs_dict["input_ids"]

     lowerCamelCase__  =     input_ids[:1, :]
     lowerCamelCase__  =     inputs_dict["attention_mask"][:1, :]
     lowerCamelCase__  =     inputs_dict["head_mask"]
     lowerCamelCase__  =     1

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

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






def    lowerCamelCase_     (    lowercase__				,     lowercase__				,     lowercase__				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     ):
 if attention_mask is None:
  lowerCamelCase__  =     tf.cast(tf.math.not_equal(lowercase__				,     config.pad_token_id)				,     tf.inta)
 if decoder_attention_mask is None:
  lowerCamelCase__  =     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__  =     tf.ones((config.encoder_layers, config.encoder_attention_heads))
 if decoder_head_mask is None:
  lowerCamelCase__  =     tf.ones((config.decoder_layers, config.decoder_attention_heads))
 if cross_attn_head_mask is None:
  lowerCamelCase__  =     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       (							_lowerCamelCase ,       _lowerCamelCase ,       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    a__				(					self     :     List[Any]     )							->							Optional[Any]:

     '''simple docstring'''




     lowerCamelCase__  =     TFBlenderbotSmallModelTester(self     )
     lowerCamelCase__  =     ConfigTester(self				,     config_class=__lowerCamelCase     )

    def    a__				(					self     :     Any     )							->							Tuple:

     '''simple docstring'''




     self.config_tester.run_common_tests()




    def    a__				(					self     :     List[Any]     )							->							List[str]:

     '''simple docstring'''




     lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()
     self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase     )
@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    a__				(					self     :     Optional[Any]     )							->							Tuple:

     '''simple docstring'''




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

    @cached_property
    def    a__				(					self     :     int     )							->							int:

     '''simple docstring'''




     lowerCamelCase__  =     TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name     )
     return model




    @slow
    def    a__				(					self     :     Any     )							->							Union[str, Any]:

     '''simple docstring'''




     lowerCamelCase__  =     self.tokenizer(self.src_text				,     return_tensors="tf"     )
     lowerCamelCase__  =     self.model.generate(
         model_inputs.input_ids				,     attention_mask=model_inputs.attention_mask				,     num_beams=2				,     use_cache=__lowerCamelCase				,     )
     lowerCamelCase__  =     self.tokenizer.batch_decode(generated_ids.numpy()				,     skip_special_tokens=__lowerCamelCase     )[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.",
     )

