






'''simple docstring'''


from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFConvBertForMaskedLM,
					    TFConvBertForMultipleChoice,
					    TFConvBertForQuestionAnswering,
					    TFConvBertForSequenceClassification,
					    TFConvBertForTokenClassification,
					    TFConvBertModel,
					)




class    _SCREAMING_SNAKE_CASE							:


			'''simple docstring'''





			def __init__(   self							:						Optional[Any] ,      lowercase							:						Optional[Any] ,      lowercase							:						List[Any]=1_3 ,      lowercase							:						int=7 ,      lowercase							:						Union[str, Any]=True ,      lowercase							:						List[str]=True ,      lowercase							:						Dict=True ,      lowercase							:						Optional[Any]=True ,      lowercase							:						Union[str, Any]=9_9 ,      lowercase							:						List[str]=3_2 ,      lowercase							:						Union[str, Any]=2 ,      lowercase							:						str=4 ,      lowercase							:						Dict=3_7 ,      lowercase							:						Optional[int]="gelu" ,      lowercase							:						List[Any]=0.1 ,      lowercase							:						str=0.1 ,      lowercase							:						Dict=5_1_2 ,      lowercase							:						Dict=1_6 ,      lowercase							:						List[str]=2 ,      lowercase							:						Dict=0.0_2 ,      lowercase							:						str=3 ,      lowercase							:						int=4 ,      lowercase							:						Union[str, Any]=None ,      )							->    Any:

									'''simple docstring'''







									UpperCamelCase__         = parent
									UpperCamelCase__         = 1_3
									UpperCamelCase__         = 7
									UpperCamelCase__         = True
									UpperCamelCase__         = True
									UpperCamelCase__         = True
									UpperCamelCase__         = True
									UpperCamelCase__         = 9_9
									UpperCamelCase__         = 3_8_4
									UpperCamelCase__         = 2
									UpperCamelCase__         = 4
									UpperCamelCase__         = 3_7
									UpperCamelCase__         = """gelu"""
									UpperCamelCase__         = 0.1
									UpperCamelCase__         = 0.1
									UpperCamelCase__         = 5_1_2
									UpperCamelCase__         = 1_6
									UpperCamelCase__         = 2
									UpperCamelCase__         = 0.0_2
									UpperCamelCase__         = 3
									UpperCamelCase__         = 4
									UpperCamelCase__         = 1_2_8
									UpperCamelCase__         = 2
									UpperCamelCase__         = 9
									UpperCamelCase__         = 1
									UpperCamelCase__         = None






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

									'''simple docstring'''







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

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

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

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

									UpperCamelCase__         = ConvBertConfig(
									    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 ,      initializer_range=self.initializer_range ,      return_dict=A_ ,      )

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






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

									'''simple docstring'''







									UpperCamelCase__         = TFConvBertModel(config=A_			)
									UpperCamelCase__         = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

									UpperCamelCase__         = [input_ids, input_mask]
									UpperCamelCase__         = model(A_			)

									UpperCamelCase__         = model(A_			)

									self.parent.assertEqual(result.last_hidden_state.shape ,      (self.batch_size, self.seq_length, self.hidden_size)			)






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

									'''simple docstring'''







									UpperCamelCase__         = TFConvBertForMaskedLM(config=A_			)
									UpperCamelCase__         = {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}
									UpperCamelCase__         = model(A_			)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.seq_length, self.vocab_size)			)






			def 				A      (   self							:						Tuple ,      lowercase							:						Any ,      lowercase							:						Any ,      lowercase							:						Tuple ,      lowercase							:						List[str] ,      lowercase							:						Dict ,      lowercase							:						Dict ,      lowercase							:						List[str]			)							->    List[str]:

									'''simple docstring'''







									UpperCamelCase__         = self.num_labels
									UpperCamelCase__         = TFConvBertForSequenceClassification(config=A_			)
									UpperCamelCase__         = {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}

									UpperCamelCase__         = model(A_			)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.num_labels)			)






			def 				A      (   self							:						Any ,      lowercase							:						Any ,      lowercase							:						Dict ,      lowercase							:						List[str] ,      lowercase							:						Dict ,      lowercase							:						Union[str, Any] ,      lowercase							:						List[Any] ,      lowercase							:						Dict			)							->    Tuple:

									'''simple docstring'''







									UpperCamelCase__         = self.num_choices
									UpperCamelCase__         = TFConvBertForMultipleChoice(config=A_			)
									UpperCamelCase__         = tf.tile(tf.expand_dims(A_ ,      1			) ,      (1, self.num_choices, 1)			)
									UpperCamelCase__         = tf.tile(tf.expand_dims(A_ ,      1			) ,      (1, self.num_choices, 1)			)
									UpperCamelCase__         = tf.tile(tf.expand_dims(A_ ,      1			) ,      (1, self.num_choices, 1)			)
									UpperCamelCase__         = {
									    """input_ids""": multiple_choice_inputs_ids,
									    """attention_mask""": multiple_choice_input_mask,
									    """token_type_ids""": multiple_choice_token_type_ids,
									}
									UpperCamelCase__         = model(A_			)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.num_choices)			)






			def 				A      (   self							:						Optional[int] ,      lowercase							:						str ,      lowercase							:						Optional[Any] ,      lowercase							:						List[Any] ,      lowercase							:						Union[str, Any] ,      lowercase							:						Optional[Any] ,      lowercase							:						List[Any] ,      lowercase							:						Union[str, Any]			)							->    str:

									'''simple docstring'''







									UpperCamelCase__         = self.num_labels
									UpperCamelCase__         = TFConvBertForTokenClassification(config=A_			)
									UpperCamelCase__         = {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}
									UpperCamelCase__         = model(A_			)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.seq_length, self.num_labels)			)






			def 				A      (   self							:						Any ,      lowercase							:						Optional[Any] ,      lowercase							:						Tuple ,      lowercase							:						Any ,      lowercase							:						List[Any] ,      lowercase							:						List[str] ,      lowercase							:						List[Any] ,      lowercase							:						List[str]			)							->    Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__         = TFConvBertForQuestionAnswering(config=A_			)
									UpperCamelCase__         = {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}

									UpperCamelCase__         = model(A_			)
									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							:						List[Any]			)							->    str:

									'''simple docstring'''







									UpperCamelCase__         = self.prepare_config_and_inputs()
									(
									    (
									    UpperCamelCase__						
									)    ,   (
									    UpperCamelCase__						
									)    ,   (
									    UpperCamelCase__						
									)    ,   (
									    UpperCamelCase__						
									)    ,   (
									    UpperCamelCase__						
									)    ,   (
									    UpperCamelCase__						
									)    ,   (
									    UpperCamelCase__						
									)    ,   						
									)         = config_and_inputs
									UpperCamelCase__         = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
									return config, inputs_dict




@require_tf
class    _SCREAMING_SNAKE_CASE							(		_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,unittest.TestCase	):


			'''simple docstring'''





			__a							:							Optional[Any]					     =					(
			    (
			        TFConvBertModel,
			        TFConvBertForMaskedLM,
			        TFConvBertForQuestionAnswering,
			        TFConvBertForSequenceClassification,
			        TFConvBertForTokenClassification,
			        TFConvBertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			__a							:							Any					     =					(
			    {
			        "feature-extraction": TFConvBertModel,
			        "fill-mask": TFConvBertForMaskedLM,
			        "question-answering": TFConvBertForQuestionAnswering,
			        "text-classification": TFConvBertForSequenceClassification,
			        "token-classification": TFConvBertForTokenClassification,
			        "zero-shot": TFConvBertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__a							:							Tuple					     =					False
			__a							:							Any					     =					False
			__a							:							Optional[int]					     =					False






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

									'''simple docstring'''







									UpperCamelCase__         = TFConvBertModelTester(self			)
									UpperCamelCase__         = ConfigTester(self ,      config_class=A_ ,      hidden_size=3_7			)






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

									'''simple docstring'''







									self.config_tester.run_common_tests()






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

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*A_			)






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

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*A_			)






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

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_multiple_choice(*A_			)






			def 				A      (   self							:						int			)							->    str:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*A_			)






			def 				A      (   self							:						Dict			)							->    Any:

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*A_			)






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

									'''simple docstring'''







									UpperCamelCase__         = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*A_			)






			@slow
			def 				A      (   self							:						Dict			)							->    int:

									'''simple docstring'''







									UpperCamelCase__    ,   UpperCamelCase__         = self.model_tester.prepare_config_and_inputs_for_common()
									UpperCamelCase__         = True
									UpperCamelCase__         = True

									if hasattr(A_ ,      """use_cache"""			):
															UpperCamelCase__         = True

									UpperCamelCase__         = getattr(self.model_tester ,      """encoder_seq_length""" ,      self.model_tester.seq_length			)
									UpperCamelCase__         = getattr(self.model_tester ,      """key_length""" ,      A_			)

									for model_class in self.all_model_classes:
															UpperCamelCase__         = self._prepare_for_class(A_ ,      A_			)
															UpperCamelCase__         = model_class(A_			)
															UpperCamelCase__         = len(model(A_			)			)

															with tempfile.TemporaryDirectory() as tmpdirname:
																					model.save_pretrained(A_ ,      saved_model=A_			)
																					UpperCamelCase__         = os.path.join(A_ ,      """saved_model""" ,      """1"""			)
																					UpperCamelCase__         = tf.keras.models.load_model(A_			)
																					UpperCamelCase__         = model(A_			)

																					if self.is_encoder_decoder:
																											UpperCamelCase__         = outputs["""encoder_hidden_states"""]
																											UpperCamelCase__         = outputs["""encoder_attentions"""]
																					else:
																											UpperCamelCase__         = outputs["""hidden_states"""]
																											UpperCamelCase__         = outputs["""attentions"""]

																					self.assertEqual(len(A_			) ,      A_			)

																					UpperCamelCase__         = getattr(
																					    self.model_tester ,      """expected_num_hidden_layers""" ,      self.model_tester.num_hidden_layers + 1			)

																					self.assertEqual(len(A_			) ,      A_			)
																					self.assertListEqual(
																					    list(output_hidden_states[0].shape[-2:]			) ,      [self.model_tester.seq_length, self.model_tester.hidden_size] ,      )

																					self.assertEqual(len(A_			) ,      self.model_tester.num_hidden_layers			)
																					self.assertListEqual(
																					    list(output_attentions[0].shape[-3:]			) ,      [self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,      )






			@slow
			def 				A      (   self							:						Any			)							->    Optional[int]:

									'''simple docstring'''







									UpperCamelCase__         = TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""			)
									self.assertIsNotNone(A_			)







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

									'''simple docstring'''







									UpperCamelCase__    ,   UpperCamelCase__         = self.model_tester.prepare_config_and_inputs_for_common()
									UpperCamelCase__         = True
									UpperCamelCase__         = getattr(self.model_tester ,      """decoder_seq_length""" ,      self.model_tester.seq_length			)
									UpperCamelCase__         = getattr(self.model_tester ,      """encoder_seq_length""" ,      self.model_tester.seq_length			)
									UpperCamelCase__         = getattr(self.model_tester ,      """key_length""" ,      A_			)
									UpperCamelCase__         = getattr(self.model_tester ,      """key_length""" ,      A_			)

									def check_decoder_attentions_output(lowercase							:						Any			):
															UpperCamelCase__         = len(A_			)
															self.assertEqual(out_len % 2 ,      0			)
															UpperCamelCase__         = outputs.decoder_attentions
															self.assertEqual(len(A_			) ,      self.model_tester.num_hidden_layers			)
															self.assertListEqual(
															    list(decoder_attentions[0].shape[-3:]			) ,      [self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length] ,      )

									def check_encoder_attentions_output(lowercase							:						int			):
															UpperCamelCase__         = [
															    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
															]
															self.assertEqual(len(A_			) ,      self.model_tester.num_hidden_layers			)
															self.assertListEqual(
															    list(attentions[0].shape[-3:]			) ,      [self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,      )

									for model_class in self.all_model_classes:
															UpperCamelCase__         = True
															UpperCamelCase__         = False
															UpperCamelCase__         = model_class(A_			)
															UpperCamelCase__         = model(self._prepare_for_class(A_ ,      A_			)			)
															UpperCamelCase__         = len(A_			)
															self.assertEqual(config.output_hidden_states ,      A_			)
															check_encoder_attentions_output(A_			)

															if self.is_encoder_decoder:
																					UpperCamelCase__         = model_class(A_			)
																					UpperCamelCase__         = model(self._prepare_for_class(A_ ,      A_			)			)
																					self.assertEqual(config.output_hidden_states ,      A_			)
																					check_decoder_attentions_output(A_			)

															# Check that output attentions can also be changed via the config
															del inputs_dict["output_attentions"]
															UpperCamelCase__         = True
															UpperCamelCase__         = model_class(A_			)
															UpperCamelCase__         = model(self._prepare_for_class(A_ ,      A_			)			)
															self.assertEqual(config.output_hidden_states ,      A_			)
															check_encoder_attentions_output(A_			)

															# Check attention is always last and order is fine
															UpperCamelCase__         = True
															UpperCamelCase__         = True
															UpperCamelCase__         = model_class(A_			)
															UpperCamelCase__         = model(self._prepare_for_class(A_ ,      A_			)			)

															self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,      len(A_			)			)
															self.assertEqual(model.config.output_hidden_states ,      A_			)
															check_encoder_attentions_output(A_			)




@require_tf
class    _SCREAMING_SNAKE_CASE							(		unittest.TestCase	):


			'''simple docstring'''





			@slow
			def 				A      (   self							:						str			)							->    List[Any]:

									'''simple docstring'''







									UpperCamelCase__         = TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""			)
									UpperCamelCase__         = tf.constant([[0, 1, 2, 3, 4, 5]]			)
									UpperCamelCase__         = model(A_			)[0]

									UpperCamelCase__         = [1, 6, 7_6_8]
									self.assertEqual(output.shape ,      A_			)

									UpperCamelCase__         = tf.constant(
									    [
									        [
									            [-0.0_3_4_7_5_4_9_3, -0.4_6_8_6_0_3_4, -0.3_0_6_3_8_8_3_2],
									            [0.2_2_6_3_7_2_4_8, -0.2_6_9_8_8_6_4_6, -0.7_4_2_3_4_2_4],
									            [0.1_0_3_2_4_8_6_8, -0.4_5_0_1_3_5_0_8, -0.5_8_2_8_0_7_8_4],
									        ]
									    ]			)
									tf.debugging.assert_near(output[:, :3, :3] ,      A_ ,      atol=1e-4			)








'''simple docstring'''


from typing import TYPE_CHECKING

from ..utils import _LazyModule


lowerCamelCase_				: List[Any]    	=							{
    '''config''': [
        '''EXTERNAL_DATA_FORMAT_SIZE_LIMIT''',
        '''OnnxConfig''',
        '''OnnxConfigWithPast''',
        '''OnnxSeq2SeqConfigWithPast''',
        '''PatchingSpec''',
    ],
    '''convert''': ['''export''', '''validate_model_outputs'''],
    '''features''': ['''FeaturesManager'''],
    '''utils''': ['''ParameterFormat''', '''compute_serialized_parameters_size'''],
}


if TYPE_CHECKING:
					from .config import (
					    EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
					    OnnxConfig,
					    OnnxConfigWithPast,
					    OnnxSeqaSeqConfigWithPast,
					    PatchingSpec,
					)
					from .convert import export, validate_model_outputs
					from .features import FeaturesManager
					from .utils import ParameterFormat, compute_serialized_parameters_size

else:
					import sys

					lowerCamelCase_				: List[Any]    	=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
