
'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 (
						    TFRoFormerForCausalLM,
						    TFRoFormerForMaskedLM,
						    TFRoFormerForMultipleChoice,
						    TFRoFormerForQuestionAnswering,
						    TFRoFormerForSequenceClassification,
						    TFRoFormerForTokenClassification,
						    TFRoFormerModel,
						)
						from transformers.models.roformer.modeling_tf_roformer import (
						    TFRoFormerSelfAttention,
						    TFRoFormerSinusoidalPositionalEmbedding,
						)




class 						a   :




				def __init__(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				int=13,    SCREAMING_SNAKE_CASE_	:				List[str]=7,    SCREAMING_SNAKE_CASE_	:				List[str]=True,    SCREAMING_SNAKE_CASE_	:				int=True,    SCREAMING_SNAKE_CASE_	:				Union[str, Any]=True,    SCREAMING_SNAKE_CASE_	:				int=True,    SCREAMING_SNAKE_CASE_	:				List[str]=99,    SCREAMING_SNAKE_CASE_	:				Any=32,    SCREAMING_SNAKE_CASE_	:				Dict=2,    SCREAMING_SNAKE_CASE_	:				List[str]=4,    SCREAMING_SNAKE_CASE_	:				Optional[int]=37,    SCREAMING_SNAKE_CASE_	:				Any="gelu",    SCREAMING_SNAKE_CASE_	:				Union[str, Any]=0.1,    SCREAMING_SNAKE_CASE_	:				Dict=0.1,    SCREAMING_SNAKE_CASE_	:				Dict=5_12,    SCREAMING_SNAKE_CASE_	:				Optional[Any]=16,    SCREAMING_SNAKE_CASE_	:				int=2,    SCREAMING_SNAKE_CASE_	:				int=0.02,    SCREAMING_SNAKE_CASE_	:				List[str]=3,    SCREAMING_SNAKE_CASE_	:				Optional[int]=4,    SCREAMING_SNAKE_CASE_	:				str=None,    ):
										snake_case       :     Optional[Any] =    parent
										snake_case       :     Dict =    13
										snake_case       :     Optional[int] =    7
										snake_case       :     int =    True
										snake_case       :     Optional[int] =    True
										snake_case       :     Union[str, Any] =    True
										snake_case       :     str =    True
										snake_case       :     Dict =    99
										snake_case       :     Any =    32
										snake_case       :     Dict =    2
										snake_case       :     Optional[int] =    4
										snake_case       :     Union[str, Any] =    37
										snake_case       :     Union[str, Any] =    '''gelu'''
										snake_case       :     List[str] =    0.1
										snake_case       :     Tuple =    0.1
										snake_case       :     Any =    5_12
										snake_case       :     Optional[int] =    16
										snake_case       :     int =    2
										snake_case       :     Union[str, Any] =    0.02
										snake_case       :     Optional[int] =    3
										snake_case       :     List[Any] =    4
										snake_case       :     List[Any] =    None




				def 	__snake_case							(							self	:				Optional[int]      ):
										snake_case       :     Dict =    ids_tensor([self.batch_size, self.seq_length],    self.vocab_size      )

										snake_case       :     Any =    None
										if self.use_input_mask:
																snake_case       :     str =    random_attention_mask([self.batch_size, self.seq_length]      )

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

										snake_case       :     Union[str, Any] =    None
										snake_case       :     Tuple =    None
										snake_case       :     Optional[int] =    None
										if self.use_labels:
																snake_case       :     Union[str, Any] =    ids_tensor([self.batch_size],    self.type_sequence_label_size      )
																snake_case       :     Union[str, Any] =    ids_tensor([self.batch_size, self.seq_length],    self.num_labels      )
																snake_case       :     List[Any] =    ids_tensor([self.batch_size],    self.num_choices      )

										snake_case       :     Dict =    RoFormerConfig(
										    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=SCREAMING_SNAKE_CASE_,    )

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




				def 	__snake_case							(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				List[Any]      ):
										snake_case       :     Optional[int] =    TFRoFormerModel(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     str =    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

										snake_case       :     Dict =    [input_ids, input_mask]
										snake_case       :     int =    model(SCREAMING_SNAKE_CASE_      )

										snake_case       :     Tuple =    model(SCREAMING_SNAKE_CASE_      )

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




				def 	__snake_case							(							self	:				List[str],    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				Union[str, Any],    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				Optional[int]      ):
										snake_case       :     Union[str, Any] =    True
										snake_case       :     Any =    TFRoFormerForCausalLM(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     List[str] =    {
										    '''input_ids''': input_ids,
										    '''attention_mask''': input_mask,
										    '''token_type_ids''': token_type_ids,
										}
										snake_case       :     int =    model(SCREAMING_SNAKE_CASE_      )['''logits''']
										self.parent.assertListEqual(
										    list(prediction_scores.numpy().shape      ),    [self.batch_size, self.seq_length, self.vocab_size]      )




				def 	__snake_case							(							self	:				int,    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				str      ):
										snake_case       :     int =    TFRoFormerForMaskedLM(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     Tuple =    {
										    '''input_ids''': input_ids,
										    '''attention_mask''': input_mask,
										    '''token_type_ids''': token_type_ids,
										}
										snake_case       :     Optional[int] =    model(SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.vocab_size)      )




				def 	__snake_case							(							self	:				Union[str, Any],    SCREAMING_SNAKE_CASE_	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				List[str]      ):
										snake_case       :     Optional[Any] =    self.num_labels
										snake_case       :     List[Any] =    TFRoFormerForSequenceClassification(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     Any =    {
										    '''input_ids''': input_ids,
										    '''attention_mask''': input_mask,
										    '''token_type_ids''': token_type_ids,
										}

										snake_case       :     Optional[int] =    model(SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_labels)      )




				def 	__snake_case							(							self	:				Dict,    SCREAMING_SNAKE_CASE_	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				Optional[Any]      ):
										snake_case       :     Optional[Any] =    self.num_choices
										snake_case       :     Optional[Any] =    TFRoFormerForMultipleChoice(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     List[Any] =    tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_,    1      ),    (1, self.num_choices, 1)      )
										snake_case       :     List[Any] =    tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_,    1      ),    (1, self.num_choices, 1)      )
										snake_case       :     Optional[Any] =    tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_,    1      ),    (1, self.num_choices, 1)      )
										snake_case       :     Union[str, Any] =    {
										    '''input_ids''': multiple_choice_inputs_ids,
										    '''attention_mask''': multiple_choice_input_mask,
										    '''token_type_ids''': multiple_choice_token_type_ids,
										}
										snake_case       :     Optional[Any] =    model(SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_choices)      )




				def 	__snake_case							(							self	:				Tuple,    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				Any      ):
										snake_case       :     Optional[Any] =    self.num_labels
										snake_case       :     str =    TFRoFormerForTokenClassification(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     Dict =    {
										    '''input_ids''': input_ids,
										    '''attention_mask''': input_mask,
										    '''token_type_ids''': token_type_ids,
										}
										snake_case       :     Optional[Any] =    model(SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.num_labels)      )




				def 	__snake_case							(							self	:				Any,    SCREAMING_SNAKE_CASE_	:				Tuple,    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Union[str, Any],    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				int      ):
										snake_case       :     Dict =    TFRoFormerForQuestionAnswering(config=SCREAMING_SNAKE_CASE_      )
										snake_case       :     Any =    {
										    '''input_ids''': input_ids,
										    '''attention_mask''': input_mask,
										    '''token_type_ids''': token_type_ids,
										}

										snake_case       :     Optional[Any] =    model(SCREAMING_SNAKE_CASE_      )
										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 	__snake_case							(							self	:				List[Any]      ):
										snake_case       :     List[Any] =    self.prepare_config_and_inputs()
										(
										    snake_case					
										)       :     Tuple =    config_and_inputs
										snake_case       :     Optional[int] =    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
										return config, inputs_dict




@require_tf
class 						a   (				__magic_name__				,__magic_name__				,unittest.TestCase    ):
				_snake_case		    = (
				    (
				        TFRoFormerModel,
				        TFRoFormerForCausalLM,
				        TFRoFormerForMaskedLM,
				        TFRoFormerForQuestionAnswering,
				        TFRoFormerForSequenceClassification,
				        TFRoFormerForTokenClassification,
				        TFRoFormerForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				_snake_case		    = (
				    {
				        '''feature-extraction''': TFRoFormerModel,
				        '''fill-mask''': TFRoFormerForMaskedLM,
				        '''question-answering''': TFRoFormerForQuestionAnswering,
				        '''text-classification''': TFRoFormerForSequenceClassification,
				        '''text-generation''': TFRoFormerForCausalLM,
				        '''token-classification''': TFRoFormerForTokenClassification,
				        '''zero-shot''': TFRoFormerForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)

				_snake_case		    = False
				_snake_case		    = False




				def 	__snake_case							(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Optional[int]      ):
										if pipeline_test_casse_name == "TextGenerationPipelineTests":
																return True

										return False




				def 	__snake_case							(							self	:				Optional[int]      ):
										snake_case       :     Optional[int] =    TFRoFormerModelTester(self      )
										snake_case       :     List[str] =    ConfigTester(self,    config_class=SCREAMING_SNAKE_CASE_,    hidden_size=37      )




				def 	__snake_case							(							self	:				Optional[Any]      ):
										self.config_tester.run_common_tests()




				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     Tuple =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				List[str]      ):
										snake_case       :     Optional[int] =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Any      ):
										snake_case       :     List[str] =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				List[Any]      ):
										snake_case       :     Tuple =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				List[str]      ):
										snake_case       :     List[str] =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				List[Any]      ):
										snake_case       :     List[str] =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Any      ):
										snake_case       :     Any =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_      )




				@slow
				def 	__snake_case							(							self	:				Optional[Any]      ):
										snake_case       :     Optional[Any] =    TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''      )
										self.assertIsNotNone(SCREAMING_SNAKE_CASE_      )




@require_tf
class 						a   (				unittest.TestCase    ):




				@slow
				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     Dict =    TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''      )
										snake_case       :     str =    tf.constant([[0, 1, 2, 3, 4, 5]]      )
										snake_case       :     Dict =    model(SCREAMING_SNAKE_CASE_      )[0]

										# TODO Replace vocab size
										snake_case       :     Optional[int] =    5_00_00

										snake_case       :     int =    [1, 6, vocab_size]
										self.assertEqual(output.shape,    SCREAMING_SNAKE_CASE_      )

										print(output[:, :3, :3]      )

										# TODO Replace values below with what was printed above.
										snake_case       :     int =    tf.constant(
										    [
										        [
										            [-0.12053341, -1.0264901, 0.29221946],
										            [-1.5133783, 0.197433, 0.15190607],
										            [-5.0135403, -3.900256, -0.84038764],
										        ]
										    ]      )
										tf.debugging.assert_near(output[:, :3, :3],    SCREAMING_SNAKE_CASE_,    atol=1e-4      )




@require_tf
class 						a   (				unittest.TestCase    ):
				_snake_case		    = 1e-4




				def 	__snake_case							(							self	:				int      ):
										snake_case       :     Optional[Any] =    tf.constant([[4, 10]]      )
										snake_case       :     Dict =    TFRoFormerSinusoidalPositionalEmbedding(num_positions=6,    embedding_dim=6      )

										snake_case       :     Optional[int] =    emba(input_ids.shape      )
										snake_case       :     Any =    tf.constant(
										    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]      )

										tf.debugging.assert_near(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    atol=self.tolerance      )




				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     Dict =    tf.constant(
										    [
										        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
										        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
										        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
										    ]      )
										snake_case       :     List[Any] =    TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12,    embedding_dim=5_12      )
										emba([2, 16, 5_12]      )
										snake_case       :     List[str] =    emba.weight[:3, :5]

										tf.debugging.assert_near(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    atol=self.tolerance      )




@require_tf
class 						a   (				unittest.TestCase    ):
				_snake_case		    = 1e-4




				def 	__snake_case							(							self	:				Any      ):
										# 2,12,16,64
										snake_case       :     List[str] =    tf.reshape(tf.range(2 * 12 * 16 * 64,    dtype=tf.floataa      ),    shape=(2, 12, 16, 64)      ) / 1_00

										snake_case       :     int =    -tf.reshape(tf.range(2 * 12 * 16 * 64,    dtype=tf.floataa      ),    shape=(2, 12, 16, 64)      ) / 1_00

										snake_case       :     Union[str, Any] =    TFRoFormerSinusoidalPositionalEmbedding(num_positions=32,    embedding_dim=64      )
										snake_case       :     List[Any] =    embed_positions([2, 16, 7_68]      )[None, None, :, :]

										snake_case       :     str =    TFRoFormerSelfAttention.apply_rotary_position_embeddings(
										    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_      )

										snake_case       :     List[Any] =    tf.constant(
										    [
										        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
										        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
										        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
										        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
										        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
										        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
										    ]      )
										snake_case       :     List[str] =    tf.constant(
										    [
										        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
										        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
										        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
										        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
										        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
										        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
										    ]      )

										tf.debugging.assert_near(query_layer[0, 0, :6, :8],    SCREAMING_SNAKE_CASE_,    atol=self.tolerance      )
										tf.debugging.assert_near(key_layer[0, 0, :6, :8],    SCREAMING_SNAKE_CASE_,    atol=self.tolerance      )



'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase    					=   {
    "configuration_convbert": ["CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ConvBertConfig", "ConvBertOnnxConfig"],
    "tokenization_convbert": ["ConvBertTokenizer"],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCAmelCase    					=   ["ConvBertTokenizerFast"]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCAmelCase    					=   [
						    "CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "ConvBertForMaskedLM",
						    "ConvBertForMultipleChoice",
						    "ConvBertForQuestionAnswering",
						    "ConvBertForSequenceClassification",
						    "ConvBertForTokenClassification",
						    "ConvBertLayer",
						    "ConvBertModel",
						    "ConvBertPreTrainedModel",
						    "load_tf_weights_in_convbert",
						]


try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCAmelCase    					=   [
						    "TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "TFConvBertForMaskedLM",
						    "TFConvBertForMultipleChoice",
						    "TFConvBertForQuestionAnswering",
						    "TFConvBertForSequenceClassification",
						    "TFConvBertForTokenClassification",
						    "TFConvBertLayer",
						    "TFConvBertModel",
						    "TFConvBertPreTrainedModel",
						]


if TYPE_CHECKING:
						from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
						from .tokenization_convbert import ConvBertTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_convbert_fast import ConvBertTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_convbert import (
												    CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ConvBertForMaskedLM,
												    ConvBertForMultipleChoice,
												    ConvBertForQuestionAnswering,
												    ConvBertForSequenceClassification,
												    ConvBertForTokenClassification,
												    ConvBertLayer,
												    ConvBertModel,
												    ConvBertPreTrainedModel,
												    load_tf_weights_in_convbert,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_convbert import (
												    TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFConvBertForMaskedLM,
												    TFConvBertForMultipleChoice,
												    TFConvBertForQuestionAnswering,
												    TFConvBertForSequenceClassification,
												    TFConvBertForTokenClassification,
												    TFConvBertLayer,
												    TFConvBertModel,
												    TFConvBertPreTrainedModel,
												)


else:
						import sys

						UpperCAmelCase    					=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

