




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    lowercase_		(SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	unittest.TestCase ):
						lowerCAmelCase__			      =(
						    (
						        TFMobileBertModel,
						        TFMobileBertForMaskedLM,
						        TFMobileBertForNextSentencePrediction,
						        TFMobileBertForPreTraining,
						        TFMobileBertForQuestionAnswering,
						        TFMobileBertForSequenceClassification,
						        TFMobileBertForTokenClassification,
						        TFMobileBertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						lowerCAmelCase__			      =(
						    {
						        "feature-extraction": TFMobileBertModel,
						        "fill-mask": TFMobileBertForMaskedLM,
						        "question-answering": TFMobileBertForQuestionAnswering,
						        "text-classification": TFMobileBertForSequenceClassification,
						        "token-classification": TFMobileBertForTokenClassification,
						        "zero-shot": TFMobileBertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False



						def 	__a					(			self	:   List[str]					,							snake_case__	:   List[Any]					,							snake_case__	:   Any					,							snake_case__	:   Dict=False  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							super()._prepare_for_class(snake_case__					,							snake_case__					,							return_labels=snake_case__  )

								if return_labels:
										if model_class in get_values(snake_case__  ):
												SCREAMING_SNAKE_CASE_					      =							tf.zeros(self.model_tester.batch_size					,							dtype=tf.intaa  )

								return inputs_dict



						class    lowercase_		(SCREAMING_SNAKE_CASE__ ):



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

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							parent
														SCREAMING_SNAKE_CASE_					      =							batch_size
														SCREAMING_SNAKE_CASE_					      =							seq_length
														SCREAMING_SNAKE_CASE_					      =							is_training
														SCREAMING_SNAKE_CASE_					      =							use_input_mask
														SCREAMING_SNAKE_CASE_					      =							use_token_type_ids
														SCREAMING_SNAKE_CASE_					      =							use_labels
														SCREAMING_SNAKE_CASE_					      =							vocab_size
														SCREAMING_SNAKE_CASE_					      =							hidden_size
														SCREAMING_SNAKE_CASE_					      =							num_hidden_layers
														SCREAMING_SNAKE_CASE_					      =							num_attention_heads
														SCREAMING_SNAKE_CASE_					      =							intermediate_size
														SCREAMING_SNAKE_CASE_					      =							hidden_act
														SCREAMING_SNAKE_CASE_					      =							hidden_dropout_prob
														SCREAMING_SNAKE_CASE_					      =							attention_probs_dropout_prob
														SCREAMING_SNAKE_CASE_					      =							max_position_embeddings
														SCREAMING_SNAKE_CASE_					      =							type_vocab_size
														SCREAMING_SNAKE_CASE_					      =							type_sequence_label_size
														SCREAMING_SNAKE_CASE_					      =							initializer_range
														SCREAMING_SNAKE_CASE_					      =							num_labels
														SCREAMING_SNAKE_CASE_					      =							num_choices
														SCREAMING_SNAKE_CASE_					      =							scope
														SCREAMING_SNAKE_CASE_					      =							embedding_size



												def 	__a					(			self	:   Dict  ):

														"""simple docstring"""

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

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

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

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

														SCREAMING_SNAKE_CASE_					      =							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 	__a					(			self	:   int					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   List[str]					,							snake_case__	:   str					,							snake_case__	:   Tuple					,							snake_case__	:   int					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[Any]  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							TFMobileBertModel(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )

														SCREAMING_SNAKE_CASE_					      =							[input_ids, input_mask]
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )

														SCREAMING_SNAKE_CASE_					      =							model(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 	__a					(			self	:   Dict					,							snake_case__	:   int					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   int					,							snake_case__	:   Dict					,							snake_case__	:   Tuple					,							snake_case__	:   Optional[int]					,							snake_case__	:   int  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForMaskedLM(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
														self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.seq_length, self.vocab_size)  )



												def 	__a					(			self	:   List[Any]					,							snake_case__	:   Tuple					,							snake_case__	:   Any					,							snake_case__	:   str					,							snake_case__	:   int					,							snake_case__	:   List[Any]					,							snake_case__	:   Any					,							snake_case__	:   Optional[int]  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForNextSentencePrediction(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
														self.parent.assertEqual(result.logits.shape					,							(self.batch_size, 2)  )



												def 	__a					(			self	:   str					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Dict					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Any					,							snake_case__	:   int					,							snake_case__	:   Dict  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForPreTraining(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(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 	__a					(			self	:   str					,							snake_case__	:   int					,							snake_case__	:   Dict					,							snake_case__	:   int					,							snake_case__	:   int					,							snake_case__	:   Optional[int]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Any  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							self.num_labels
														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForSequenceClassification(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
														self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.num_labels)  )



												def 	__a					(			self	:   Optional[Any]					,							snake_case__	:   List[str]					,							snake_case__	:   Dict					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Optional[int]					,							snake_case__	:   Tuple					,							snake_case__	:   Any					,							snake_case__	:   List[str]  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							self.num_choices
														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForMultipleChoice(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							tf.tile(tf.expand_dims(snake_case__					,							1  )					,							(1, self.num_choices, 1)  )
														SCREAMING_SNAKE_CASE_					      =							tf.tile(tf.expand_dims(snake_case__					,							1  )					,							(1, self.num_choices, 1)  )
														SCREAMING_SNAKE_CASE_					      =							tf.tile(tf.expand_dims(snake_case__					,							1  )					,							(1, self.num_choices, 1)  )
														SCREAMING_SNAKE_CASE_					      =							{
														    'input_ids': multiple_choice_inputs_ids,
														    'attention_mask': multiple_choice_input_mask,
														    'token_type_ids': multiple_choice_token_type_ids,
														}
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
														self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.num_choices)  )



												def 	__a					(			self	:   Dict					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[int]					,							snake_case__	:   List[Any]					,							snake_case__	:   Dict					,							snake_case__	:   List[str]					,							snake_case__	:   Tuple					,							snake_case__	:   Any  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							self.num_labels
														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForTokenClassification(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
														self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.seq_length, self.num_labels)  )



												def 	__a					(			self	:   int					,							snake_case__	:   Any					,							snake_case__	:   str					,							snake_case__	:   str					,							snake_case__	:   str					,							snake_case__	:   Optional[int]					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[int]  ):

														"""simple docstring"""

														SCREAMING_SNAKE_CASE_					      =							TFMobileBertForQuestionAnswering(config=snake_case__  )
														SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
														SCREAMING_SNAKE_CASE_					      =							model(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 	__a					(			self	:   List[str]  ):

														"""simple docstring"""

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



						def 	__a					(			self	:   int  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFMobileBertModelTest.TFMobileBertModelTester(self  )
								SCREAMING_SNAKE_CASE_					      =							ConfigTester(self					,							config_class=snake_case__					,							hidden_size=37  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								self.config_tester.run_common_tests()



						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_model(*snake_case__  )



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__  )



						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__  )



						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__  )



						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__  )



						def 	__a					(			self	:   int  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__  )



						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__  )



						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__  )






						@slow
						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

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



@require_tf
class    lowercase_		(unittest.TestCase ):



						@slow
						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFMobileBertForPreTraining.from_pretrained('google/mobilebert-uncased'  )
								SCREAMING_SNAKE_CASE_					      =							tf.constant([[0, 1, 2, 3, 4, 5]]  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )[0]

								SCREAMING_SNAKE_CASE_					      =							[1, 6, 3_05_22]
								self.assertEqual(output.shape					,							snake_case__  )

								SCREAMING_SNAKE_CASE_					      =							tf.constant(
								    [
								        [
								            [-4.5_91_95_47, -9.24_82_95, -9.64_52_56],
								            [-6.7_30_61_75, -6.44_02_84, -6.6_05_28_37],
								            [-7.2_74_35_06, -6.7_84_79_15, -6.02_46_73],
								        ]
								    ]  )
								tf.debugging.assert_near(output[:, :3, :3]					,							snake_case__					,							atol=1e-4  )





from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE:     Optional[int]									= {
    '''configuration_roformer''': ['''ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RoFormerConfig''', '''RoFormerOnnxConfig'''],
    '''tokenization_roformer''': ['''RoFormerTokenizer'''],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						SCREAMING_SNAKE_CASE:     Tuple									= ['''RoFormerTokenizerFast''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						SCREAMING_SNAKE_CASE:     Any									= [
						    '''ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''RoFormerForCausalLM''',
						    '''RoFormerForMaskedLM''',
						    '''RoFormerForMultipleChoice''',
						    '''RoFormerForQuestionAnswering''',
						    '''RoFormerForSequenceClassification''',
						    '''RoFormerForTokenClassification''',
						    '''RoFormerLayer''',
						    '''RoFormerModel''',
						    '''RoFormerPreTrainedModel''',
						    '''load_tf_weights_in_roformer''',
						]


try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						SCREAMING_SNAKE_CASE:     Dict									= [
						    '''TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFRoFormerForCausalLM''',
						    '''TFRoFormerForMaskedLM''',
						    '''TFRoFormerForMultipleChoice''',
						    '''TFRoFormerForQuestionAnswering''',
						    '''TFRoFormerForSequenceClassification''',
						    '''TFRoFormerForTokenClassification''',
						    '''TFRoFormerLayer''',
						    '''TFRoFormerModel''',
						    '''TFRoFormerPreTrainedModel''',
						]


try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						SCREAMING_SNAKE_CASE:     str									= [
						    '''FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''FlaxRoFormerForMaskedLM''',
						    '''FlaxRoFormerForMultipleChoice''',
						    '''FlaxRoFormerForQuestionAnswering''',
						    '''FlaxRoFormerForSequenceClassification''',
						    '''FlaxRoFormerForTokenClassification''',
						    '''FlaxRoFormerModel''',
						    '''FlaxRoFormerPreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_roformer import ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, RoFormerConfig, RoFormerOnnxConfig
						from .tokenization_roformer import RoFormerTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_roformer_fast import RoFormerTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_roformer import (
												    ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    RoFormerForCausalLM,
												    RoFormerForMaskedLM,
												    RoFormerForMultipleChoice,
												    RoFormerForQuestionAnswering,
												    RoFormerForSequenceClassification,
												    RoFormerForTokenClassification,
												    RoFormerLayer,
												    RoFormerModel,
												    RoFormerPreTrainedModel,
												    load_tf_weights_in_roformer,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_roformer import (
												    TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFRoFormerForCausalLM,
												    TFRoFormerForMaskedLM,
												    TFRoFormerForMultipleChoice,
												    TFRoFormerForQuestionAnswering,
												    TFRoFormerForSequenceClassification,
												    TFRoFormerForTokenClassification,
												    TFRoFormerLayer,
												    TFRoFormerModel,
												    TFRoFormerPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_roformer import (
												    FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    FlaxRoFormerForMaskedLM,
												    FlaxRoFormerForMultipleChoice,
												    FlaxRoFormerForQuestionAnswering,
												    FlaxRoFormerForSequenceClassification,
												    FlaxRoFormerForTokenClassification,
												    FlaxRoFormerModel,
												    FlaxRoFormerPreTrainedModel,
												)


else:
						import sys

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