




from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

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


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
     TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
     TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     LayoutLMvaConfig,
     TFLayoutLMvaForQuestionAnswering,
     TFLayoutLMvaForSequenceClassification,
     TFLayoutLMvaForTokenClassification,
     TFLayoutLMvaModel,
 )

if is_vision_available():
 from PIL import Image

 from transformers import LayoutLMvaImageProcessor







class   A:



 '''simple docstring'''


 def __init__(				self					:  str						,							A_					:  Dict						,							A_					:  int=2						,							A_					:  Any=3						,							A_					:  Tuple=4						,							A_					:  int=2						,							A_					:  Tuple=7						,							A_					:  Any=True						,							A_					:  str=True						,							A_					:  int=True						,							A_					:  Optional[Any]=True						,							A_					:  Union[str, Any]=99						,							A_					:  Union[str, Any]=36						,							A_					:  str=2						,							A_					:  Tuple=4						,							A_					:  str=37						,							A_					:  List[str]="gelu"						,							A_					:  Optional[int]=0.1						,							A_					:  Union[str, Any]=0.1						,							A_					:  List[Any]=512						,							A_					:  int=16						,							A_					:  List[Any]=2						,							A_					:  Dict=0.02						,							A_					:  Dict=6						,							A_					:  Dict=6						,							A_					:  Union[str, Any]=3						,							A_					:  Dict=4						,							A_					:  Union[str, Any]=None						,							A_					:  Union[str, Any]=1000						,							)   ->	Any:

       """simple docstring"""






       lowerCamelCase_		     =    parent
       lowerCamelCase_		     =    batch_size
       lowerCamelCase_		     =    num_channels
       lowerCamelCase_		     =    image_size
       lowerCamelCase_		     =    patch_size
       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_		     =    coordinate_size
       lowerCamelCase_		     =    shape_size
       lowerCamelCase_		     =    num_labels
       lowerCamelCase_		     =    num_choices
       lowerCamelCase_		     =    scope
       lowerCamelCase_		     =    range_bbox

       # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
       lowerCamelCase_		     =    text_seq_length
       lowerCamelCase_		     =    (image_size // patch_size) ** 2 + 1
       lowerCamelCase_		     =    self.text_seq_length + self.image_seq_length

 def 				a__ (				self					:  Dict  )   ->	int:

       """simple docstring"""






       lowerCamelCase_		     =    ids_tensor([self.batch_size, self.text_seq_length]						,							self.vocab_size  )

       lowerCamelCase_		     =    ids_tensor([self.batch_size, self.text_seq_length, 4]						,							self.range_bbox  )
       lowerCamelCase_		     =    bbox.numpy()
       # Ensure that bbox is legal
       for i in range(bbox.shape[0]  ):
             for j in range(bbox.shape[1]  ):
                   if bbox[i, j, 3] < bbox[i, j, 1]:
                         lowerCamelCase_		     =    bbox[i, j, 3]
                         lowerCamelCase_		     =    bbox[i, j, 1]
                         lowerCamelCase_		     =    tmp_coordinate
                   if bbox[i, j, 2] < bbox[i, j, 0]:
                         lowerCamelCase_		     =    bbox[i, j, 2]
                         lowerCamelCase_		     =    bbox[i, j, 0]
                         lowerCamelCase_		     =    tmp_coordinate
       lowerCamelCase_		     =    tf.constant(A_  )

       lowerCamelCase_		     =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

       lowerCamelCase_		     =    None
       if self.use_input_mask:
             lowerCamelCase_		     =    random_attention_mask([self.batch_size, self.text_seq_length]  )

       lowerCamelCase_		     =    None
       if self.use_token_type_ids:
             lowerCamelCase_		     =    ids_tensor([self.batch_size, self.text_seq_length]						,							self.type_vocab_size  )

       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.text_seq_length]						,							self.num_labels  )

       lowerCamelCase_		     =    LayoutLMvaConfig(
           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						,							coordinate_size=self.coordinate_size						,							shape_size=self.shape_size						,							input_size=self.image_size						,							patch_size=self.patch_size						,							)

       return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels

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

       """simple docstring"""






       lowerCamelCase_		     =    TFLayoutLMvaModel(config=A_  )

       # text + image
       lowerCamelCase_		     =    model(A_						,							pixel_values=A_						,							training=A_  )
       lowerCamelCase_		     =    model(
           A_						,							bbox=A_						,							pixel_values=A_						,							attention_mask=A_						,							token_type_ids=A_						,							training=A_						,							)
       lowerCamelCase_		     =    model(A_						,							bbox=A_						,							pixel_values=A_						,							training=A_  )

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

       # text only
       lowerCamelCase_		     =    model(A_						,							training=A_  )
       self.parent.assertEqual(
           result.last_hidden_state.shape						,							(self.batch_size, self.text_seq_length, self.hidden_size)  )

       # image only
       lowerCamelCase_		     =    model({'pixel_values': pixel_values}						,							training=A_  )
       self.parent.assertEqual(
           result.last_hidden_state.shape						,							(self.batch_size, self.image_seq_length, self.hidden_size)  )

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

       """simple docstring"""






       lowerCamelCase_		     =    self.num_labels
       lowerCamelCase_		     =    TFLayoutLMvaForSequenceClassification(config=A_  )
       lowerCamelCase_		     =    model(
           A_						,							bbox=A_						,							pixel_values=A_						,							attention_mask=A_						,							token_type_ids=A_						,							labels=A_						,							training=A_						,							)
       self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.num_labels)  )

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

       """simple docstring"""






       lowerCamelCase_		     =    self.num_labels
       lowerCamelCase_		     =    TFLayoutLMvaForTokenClassification(config=A_  )
       lowerCamelCase_		     =    model(
           A_						,							bbox=A_						,							pixel_values=A_						,							attention_mask=A_						,							token_type_ids=A_						,							labels=A_						,							training=A_						,							)
       self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.text_seq_length, self.num_labels)  )

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

       """simple docstring"""






       lowerCamelCase_		     =    2
       lowerCamelCase_		     =    TFLayoutLMvaForQuestionAnswering(config=A_  )
       lowerCamelCase_		     =    model(
           A_						,							bbox=A_						,							pixel_values=A_						,							attention_mask=A_						,							token_type_ids=A_						,							start_positions=A_						,							end_positions=A_						,							training=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					:  int  )   ->	Dict:

       """simple docstring"""






       lowerCamelCase_		     =    self.prepare_config_and_inputs()
       ((lowerCamelCase_)     ,				(lowerCamelCase_)     ,				(lowerCamelCase_)     ,				(lowerCamelCase_)     ,				(lowerCamelCase_)     ,				(lowerCamelCase_)     ,				(lowerCamelCase_)     ,				(lowerCamelCase_))		     =    config_and_inputs
       lowerCamelCase_		     =    {
           'input_ids': input_ids,
           'bbox': bbox,
           'pixel_values': pixel_values,
           'token_type_ids': token_type_ids,
           'attention_mask': input_mask,
       }
       return config, inputs_dict







@require_tf
class   A(						UpperCamelCase							,      UpperCamelCase							,      unittest.TestCase   ):



 '''simple docstring'''


 UpperCamelCase						   =						(
     (
         TFLayoutLMvaModel,
         TFLayoutLMvaForQuestionAnswering,
         TFLayoutLMvaForSequenceClassification,
         TFLayoutLMvaForTokenClassification,
     )
     if is_tf_available()
     else ()
 )
 UpperCamelCase						   =						(
     {'''document-question-answering''': TFLayoutLMvaForQuestionAnswering, '''feature-extraction''': TFLayoutLMvaModel}
     if is_tf_available()
     else {}
 )

 UpperCamelCase						   =						False
 UpperCamelCase						   =						False
 UpperCamelCase						   =						False

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

       """simple docstring"""






       return True

 def 				a__ (				self					:  Tuple						,							A_					:  Tuple						,							A_					:  Any						,							A_					:  int=False  )   ->	dict:

       """simple docstring"""






       lowerCamelCase_		     =    copy.deepcopy(A_  )

       if model_class in get_values(A_  ):
             lowerCamelCase_		     =    {
                 k: tf.tile(tf.expand_dims(A_						,							1  )						,							(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)  )
                 if isinstance(A_						,							tf.Tensor  ) and v.ndim > 0
                 else v
                 for k, v in inputs_dict.items()
             }

       if return_labels:
             if model_class in get_values(A_  ):
                   lowerCamelCase_		     =    tf.ones(self.model_tester.batch_size						,							dtype=tf.intaa  )
             elif model_class in get_values(A_  ):
                   lowerCamelCase_		     =    tf.zeros(self.model_tester.batch_size						,							dtype=tf.intaa  )
                   lowerCamelCase_		     =    tf.zeros(self.model_tester.batch_size						,							dtype=tf.intaa  )
             elif model_class in get_values(A_  ):
                   lowerCamelCase_		     =    tf.zeros(self.model_tester.batch_size						,							dtype=tf.intaa  )
             elif model_class in get_values(A_  ):
                   lowerCamelCase_		     =    tf.zeros(
                       (self.model_tester.batch_size, self.model_tester.text_seq_length)						,							dtype=tf.intaa  )

       return inputs_dict

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

       """simple docstring"""






       lowerCamelCase_		     =    TFLayoutLMvaModelTester(self  )
       lowerCamelCase_		     =    ConfigTester(self						,							config_class=A_						,							hidden_size=37  )

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

       """simple docstring"""






       self.config_tester.run_common_tests()

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

       """simple docstring"""






       lowerCamelCase_     ,				lowerCamelCase_		     =    self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes:
             lowerCamelCase_		     =    model_class(A_  )
             if getattr(A_						,							'hf_compute_loss'						,							A_  ):
                   # The number of elements in the loss should be the same as the number of elements in the label
                   lowerCamelCase_		     =    self._prepare_for_class(inputs_dict.copy()						,							A_						,							return_labels=A_  )
                   lowerCamelCase_		     =    prepared_for_class[
                       sorted(prepared_for_class.keys() - inputs_dict.keys()						,							reverse=A_  )[0]
                   ]
                   lowerCamelCase_		     =    added_label.shape.as_list()[:1]

                   # Test that model correctly compute the loss with kwargs
                   lowerCamelCase_		     =    self._prepare_for_class(inputs_dict.copy()						,							A_						,							return_labels=A_  )
                   lowerCamelCase_		     =    prepared_for_class.pop('input_ids'  )

                   lowerCamelCase_		     =    model(A_						,							**A_  )[0]
                   self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]  )

                   # Test that model correctly compute the loss when we mask some positions
                   lowerCamelCase_		     =    self._prepare_for_class(inputs_dict.copy()						,							A_						,							return_labels=A_  )
                   lowerCamelCase_		     =    prepared_for_class.pop('input_ids'  )
                   if "labels" in prepared_for_class:
                         lowerCamelCase_		     =    prepared_for_class['labels'].numpy()
                         if len(labels.shape  ) > 1 and labels.shape[1] != 1:
                               lowerCamelCase_		     =    -100
                               lowerCamelCase_		     =    tf.convert_to_tensor(A_  )
                               lowerCamelCase_		     =    model(A_						,							**A_  )[0]
                               self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]  )
                               self.assertTrue(not np.any(np.isnan(loss.numpy()  )  )  )

                # Test that model correctly compute the loss with a dict
                   lowerCamelCase_		     =    self._prepare_for_class(inputs_dict.copy()						,							A_						,							return_labels=A_  )
                   lowerCamelCase_		     =    model(A_  )[0]
                   self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]  )

                   # Test that model correctly compute the loss with a tuple
                   lowerCamelCase_		     =    self._prepare_for_class(inputs_dict.copy()						,							A_						,							return_labels=A_  )

                   # Get keys that were added with the _prepare_for_class function
                   lowerCamelCase_		     =    prepared_for_class.keys() - inputs_dict.keys()
                   lowerCamelCase_		     =    inspect.signature(model.call  ).parameters
                   lowerCamelCase_		     =    list(signature.keys()  )

                   # Create a dictionary holding the location of the tensors in the tuple
                   lowerCamelCase_		     =    {0: 'input_ids'}
                   for label_key in label_keys:
                         lowerCamelCase_		     =    signature_names.index(A_  )
                         lowerCamelCase_		     =    label_key
                   lowerCamelCase_		     =    sorted(tuple_index_mapping.items()  )
                   # Initialize a list with their default values, update the values and convert to a tuple
                   lowerCamelCase_		     =    []

                   for name in signature_names:
                         if name != "kwargs":
                               list_input.append(signature[name].default  )

                   for index, value in sorted_tuple_index_mapping:
                         lowerCamelCase_		     =    prepared_for_class[value]

                   lowerCamelCase_		     =    tuple(A_  )

                   # Send to model
                   lowerCamelCase_		     =    model(tuple_input[:-1]  )[0]

                   self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]  )

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

       """simple docstring"""






       (
           (
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				
       )		     =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(A_						,							A_						,							A_						,							A_						,							A_						,							A_  )

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

       """simple docstring"""






       (
           (
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           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(A_						,							A_						,							A_						,							A_						,							A_						,							A_  )

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

       """simple docstring"""






       (
           (
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				
       )		     =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(
           A_						,							A_						,							A_						,							A_						,							A_						,							A_						,							A_  )

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

       """simple docstring"""






       (
           (
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				
       )		     =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(
           A_						,							A_						,							A_						,							A_						,							A_						,							A_						,							A_  )

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

       """simple docstring"""






       (
           (
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				(
           lowerCamelCase_
       )     ,				
       )		     =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(
           A_						,							A_						,							A_						,							A_						,							A_						,							A_						,							A_  )





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

       """simple docstring"""






       for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_		     =    TFLayoutLMvaModel.from_pretrained(A_  )
             self.assertIsNotNone(A_  )

def 			_SCREAMING_SNAKE_CASE			(							):


      '''simple docstring'''



      lowerCamelCase_		     =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
      return image







@require_tf
class   A(						unittest.TestCase   ):



 '''simple docstring'''


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

       """simple docstring"""






       return LayoutLMvaImageProcessor(apply_ocr=A_  ) if is_vision_available() else None





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

       """simple docstring"""






       lowerCamelCase_		     =    TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'  )

       lowerCamelCase_		     =    self.default_image_processor
       lowerCamelCase_		     =    prepare_img()
       lowerCamelCase_		     =    image_processor(images=A_						,							return_tensors='tf'  ).pixel_values

       lowerCamelCase_		     =    tf.constant([[1, 2]]  )
       lowerCamelCase_		     =    tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]]  )						,							axis=0  )

       # forward pass
       lowerCamelCase_		     =    model(input_ids=A_						,							bbox=A_						,							pixel_values=A_						,							training=A_  )

       # verify the logits
       lowerCamelCase_		     =    (1, 199, 768)
       self.assertEqual(outputs.last_hidden_state.shape						,							A_  )

       lowerCamelCase_		     =    tf.constant(
           [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]  )

       self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]						,							A_						,							atol=1E-4  )  )









from typing import TYPE_CHECKING

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


lowerCamelCase				:		Union[str, Any]     =   {
    "configuration_convbert": ["CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ConvBertConfig", "ConvBertOnnxConfig"],
    "tokenization_convbert": ["ConvBertTokenizer"],
}

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

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:		Dict     =   [
     "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:
 lowerCamelCase				:		Tuple     =   [
     "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

 lowerCamelCase				:		Optional[int]     =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



