



"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
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 (
          TF_MODEL_FOR_PRETRAINING_MAPPING,
          TFMobileBertForMaskedLM,
          TFMobileBertForMultipleChoice,
          TFMobileBertForNextSentencePrediction,
          TFMobileBertForPreTraining,
          TFMobileBertForQuestionAnswering,
          TFMobileBertForSequenceClassification,
          TFMobileBertForTokenClassification,
          TFMobileBertModel,
      )



@require_tf
class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   List[Any]						=						(
       (
           TFMobileBertModel,
           TFMobileBertForMaskedLM,
           TFMobileBertForNextSentencePrediction,
           TFMobileBertForPreTraining,
           TFMobileBertForQuestionAnswering,
           TFMobileBertForSequenceClassification,
           TFMobileBertForTokenClassification,
           TFMobileBertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   __lowerCAmelCase  :   Union[str, Any]						=						(
       {
           'feature-extraction': TFMobileBertModel,
           'fill-mask': TFMobileBertForMaskedLM,
           'question-answering': TFMobileBertForQuestionAnswering,
           'text-classification': TFMobileBertForSequenceClassification,
           'token-classification': TFMobileBertForTokenClassification,
           'zero-shot': TFMobileBertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __lowerCAmelCase  :   int						=						False
   __lowerCAmelCase  :   Union[str, Any]						=						False

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=False						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					List[Any]	=	super()._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_labels=_SCREAMING_SNAKE_CASE						)

    if return_labels:
     if model_class in get_values(_SCREAMING_SNAKE_CASE						):
      UpperCAmelCase	:					List[str]	=	tf.zeros(self.model_tester.batch_size      ,     dtype=tf.intaa						)

    return inputs_dict



   class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):

      def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=13      ,     _SCREAMING_SNAKE_CASE=7      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=99      ,     _SCREAMING_SNAKE_CASE=32      ,     _SCREAMING_SNAKE_CASE=32      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=37      ,     _SCREAMING_SNAKE_CASE="gelu"      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=512      ,     _SCREAMING_SNAKE_CASE=16      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=0.02      ,     _SCREAMING_SNAKE_CASE=3      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=None      ,     )  ->      str:





       '''simple docstring'''




       UpperCAmelCase	:					List[Any]	=	parent
       UpperCAmelCase	:					Optional[int]	=	batch_size
       UpperCAmelCase	:					Any	=	seq_length
       UpperCAmelCase	:					Union[str, Any]	=	is_training
       UpperCAmelCase	:					str	=	use_input_mask
       UpperCAmelCase	:					str	=	use_token_type_ids
       UpperCAmelCase	:					Union[str, Any]	=	use_labels
       UpperCAmelCase	:					Union[str, Any]	=	vocab_size
       UpperCAmelCase	:					int	=	hidden_size
       UpperCAmelCase	:					Tuple	=	num_hidden_layers
       UpperCAmelCase	:					str	=	num_attention_heads
       UpperCAmelCase	:					Any	=	intermediate_size
       UpperCAmelCase	:					List[str]	=	hidden_act
       UpperCAmelCase	:					Any	=	hidden_dropout_prob
       UpperCAmelCase	:					Dict	=	attention_probs_dropout_prob
       UpperCAmelCase	:					str	=	max_position_embeddings
       UpperCAmelCase	:					Tuple	=	type_vocab_size
       UpperCAmelCase	:					Union[str, Any]	=	type_sequence_label_size
       UpperCAmelCase	:					Optional[Any]	=	initializer_range
       UpperCAmelCase	:					Union[str, Any]	=	num_labels
       UpperCAmelCase	:					Any	=	num_choices
       UpperCAmelCase	:					List[Any]	=	scope
       UpperCAmelCase	:					str	=	embedding_size

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





       '''simple docstring'''




       UpperCAmelCase	:					Optional[Any]	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.vocab_size						)

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

       UpperCAmelCase	:					List[Any]	=	None
       if self.use_token_type_ids:
        UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.type_vocab_size						)

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

       UpperCAmelCase	:					str	=	MobileBertConfig(
           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      ,     embedding_size=self.embedding_size      ,     )

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

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





       '''simple docstring'''




       UpperCAmelCase	:					Any	=	TFMobileBertModel(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					List[Any]	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE						)

       UpperCAmelCase	:					Optional[int]	=	[input_ids, input_mask]
       UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE						)

       UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE						)

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

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





       '''simple docstring'''




       UpperCAmelCase	:					str	=	TFMobileBertForMaskedLM(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					Dict	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE						)
       self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)

      def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      int:





       '''simple docstring'''




       UpperCAmelCase	:					Optional[int]	=	TFMobileBertForNextSentencePrediction(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					List[Any]	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					Union[str, Any]	=	model(_SCREAMING_SNAKE_CASE						)
       self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, 2)						)

      def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      Tuple:





       '''simple docstring'''




       UpperCAmelCase	:					Optional[int]	=	TFMobileBertForPreTraining(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					str	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE						)
       self.parent.assertEqual(
           result.prediction_logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)
       self.parent.assertEqual(result.seq_relationship_logits.shape      ,     (self.batch_size, 2)						)

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





       '''simple docstring'''




       UpperCAmelCase	:					List[str]	=	self.num_labels
       UpperCAmelCase	:					Tuple	=	TFMobileBertForSequenceClassification(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					Optional[int]	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					Tuple	=	model(_SCREAMING_SNAKE_CASE						)
       self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.num_labels)						)

      def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      int:





       '''simple docstring'''




       UpperCAmelCase	:					Tuple	=	self.num_choices
       UpperCAmelCase	:					Any	=	TFMobileBertForMultipleChoice(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					str	=	tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE      ,     1						)      ,     (1, self.num_choices, 1)						)
       UpperCAmelCase	:					Any	=	tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE      ,     1						)      ,     (1, self.num_choices, 1)						)
       UpperCAmelCase	:					int	=	tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE      ,     1						)      ,     (1, self.num_choices, 1)						)
       UpperCAmelCase	:					Optional[Any]	=	{
           """input_ids""": multiple_choice_inputs_ids,
           """attention_mask""": multiple_choice_input_mask,
           """token_type_ids""": multiple_choice_token_type_ids,
       }
       UpperCAmelCase	:					Optional[Any]	=	model(_SCREAMING_SNAKE_CASE						)
       self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.num_choices)						)

      def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      List[Any]:





       '''simple docstring'''




       UpperCAmelCase	:					str	=	self.num_labels
       UpperCAmelCase	:					str	=	TFMobileBertForTokenClassification(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					List[str]	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					Any	=	model(_SCREAMING_SNAKE_CASE						)
       self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.num_labels)						)

      def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      Any:





       '''simple docstring'''




       UpperCAmelCase	:					str	=	TFMobileBertForQuestionAnswering(config=_SCREAMING_SNAKE_CASE						)
       UpperCAmelCase	:					Dict	=	{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       UpperCAmelCase	:					List[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 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





       '''simple docstring'''




       UpperCAmelCase	:					int	=	self.prepare_config_and_inputs()
       (
           (
           UpperCAmelCase
       )	,		(
           UpperCAmelCase
       )	,		(
           UpperCAmelCase
       )	,		(
           UpperCAmelCase
       )	,		(
           UpperCAmelCase
       )	,		(
           UpperCAmelCase
       )	,		(
           UpperCAmelCase
       )	,		
       )	:					Optional[int]	=	config_and_inputs
       UpperCAmelCase	:					Union[str, Any]	=	{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
       return config, inputs_dict

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





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	TFMobileBertModelTest.TFMobileBertModelTester(self						)
    UpperCAmelCase	:					Union[str, Any]	=	ConfigTester(self      ,     config_class=_SCREAMING_SNAKE_CASE      ,     hidden_size=37						)

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





    '''simple docstring'''




    self.config_tester.run_common_tests()

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





    '''simple docstring'''




    UpperCAmelCase	:					Dict	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_model(*_SCREAMING_SNAKE_CASE						)

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





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_masked_lm(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_multiple_choice(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_pretraining(*_SCREAMING_SNAKE_CASE						)

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





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_question_answering(*_SCREAMING_SNAKE_CASE						)

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





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_sequence_classification(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_token_classification(*_SCREAMING_SNAKE_CASE						)




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





    '''simple docstring'''




    for model_name in ["google/mobilebert-uncased"]:
     UpperCAmelCase	:					int	=	TFMobileBertModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
     self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)



@require_tf
class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	TFMobileBertForPreTraining.from_pretrained("""google/mobilebert-uncased"""						)
    UpperCAmelCase	:					List[str]	=	tf.constant([[0, 1, 2, 3, 4, 5]]						)
    UpperCAmelCase	:					Any	=	model(_SCREAMING_SNAKE_CASE						)[0]

    UpperCAmelCase	:					Union[str, Any]	=	[1, 6, 30522]
    self.assertEqual(output.shape      ,     _SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					int	=	tf.constant(
        [
            [
                [-4.591_9547, -9.24_8295, -9.64_5256],
                [-6.730_6175, -6.44_0284, -6.605_2837],
                [-7.274_3506, -6.784_7915, -6.02_4673],
            ]
        ]						)
    tf.debugging.assert_near(output[:, :3, :3]      ,     _SCREAMING_SNAKE_CASE      ,     atol=1E-4						)





"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


A:   Optional[Any]								=		{
    "configuration_tapas": ["TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP", "TapasConfig"],
    "tokenization_tapas": ["TapasTokenizer"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A:   Optional[int]								=		[
          "TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TapasForMaskedLM",
          "TapasForQuestionAnswering",
          "TapasForSequenceClassification",
          "TapasModel",
          "TapasPreTrainedModel",
          "load_tf_weights_in_tapas",
      ]
try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A:   List[str]								=		[
          "TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFTapasForMaskedLM",
          "TFTapasForQuestionAnswering",
          "TFTapasForSequenceClassification",
          "TFTapasModel",
          "TFTapasPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
      from .tokenization_tapas import TapasTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tapas import (
                TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
                TapasForMaskedLM,
                TapasForQuestionAnswering,
                TapasForSequenceClassification,
                TapasModel,
                TapasPreTrainedModel,
                load_tf_weights_in_tapas,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_tapas import (
                TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFTapasForMaskedLM,
                TFTapasForQuestionAnswering,
                TFTapasForSequenceClassification,
                TFTapasModel,
                TFTapasPreTrainedModel,
            )


else:
      import sys

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