

import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    NystromformerForMaskedLM,
					    NystromformerForMultipleChoice,
					    NystromformerForQuestionAnswering,
					    NystromformerForSequenceClassification,
					    NystromformerForTokenClassification,
					    NystromformerModel,
					)
					from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST






class 			A_						:
							def __init__(						self						:     Any  ,SCREAMING_SNAKE_CASE__						:     Dict  ,SCREAMING_SNAKE_CASE__						:     Dict=1_3  ,SCREAMING_SNAKE_CASE__						:     List[str]=7  ,SCREAMING_SNAKE_CASE__						:     str=True  ,SCREAMING_SNAKE_CASE__						:     List[str]=True  ,SCREAMING_SNAKE_CASE__						:     int=True  ,SCREAMING_SNAKE_CASE__						:     List[str]=True  ,SCREAMING_SNAKE_CASE__						:     Dict=9_9  ,SCREAMING_SNAKE_CASE__						:     Optional[int]=3_2  ,SCREAMING_SNAKE_CASE__						:     int=5  ,SCREAMING_SNAKE_CASE__						:     str=4  ,SCREAMING_SNAKE_CASE__						:     Any=3_7  ,SCREAMING_SNAKE_CASE__						:     str="gelu"  ,SCREAMING_SNAKE_CASE__						:     Dict=0.1  ,SCREAMING_SNAKE_CASE__						:     int=0.1  ,SCREAMING_SNAKE_CASE__						:     List[str]=5_1_2  ,SCREAMING_SNAKE_CASE__						:     Optional[int]=1_6  ,SCREAMING_SNAKE_CASE__						:     Dict=2  ,SCREAMING_SNAKE_CASE__						:     Tuple=0.02  ,SCREAMING_SNAKE_CASE__						:     Tuple=3  ,SCREAMING_SNAKE_CASE__						:     Optional[int]=4  ,SCREAMING_SNAKE_CASE__						:     Optional[Any]=None  ,):
								__lowerCamelCase							:							str   			=					parent
								__lowerCamelCase							:							List[Any]   			=					batch_size
								__lowerCamelCase							:							List[Any]   			=					seq_length
								__lowerCamelCase							:							Tuple   			=					is_training
								__lowerCamelCase							:							Optional[Any]   			=					use_input_mask
								__lowerCamelCase							:							Dict   			=					use_token_type_ids
								__lowerCamelCase							:							Optional[Any]   			=					use_labels
								__lowerCamelCase							:							List[str]   			=					vocab_size
								__lowerCamelCase							:							str   			=					hidden_size
								__lowerCamelCase							:							Any   			=					num_hidden_layers
								__lowerCamelCase							:							List[Any]   			=					num_attention_heads
								__lowerCamelCase							:							Union[str, Any]   			=					intermediate_size
								__lowerCamelCase							:							List[str]   			=					hidden_act
								__lowerCamelCase							:							Dict   			=					hidden_dropout_prob
								__lowerCamelCase							:							Optional[Any]   			=					attention_probs_dropout_prob
								__lowerCamelCase							:							Optional[int]   			=					max_position_embeddings
								__lowerCamelCase							:							int   			=					type_vocab_size
								__lowerCamelCase							:							int   			=					type_sequence_label_size
								__lowerCamelCase							:							Tuple   			=					initializer_range
								__lowerCamelCase							:							Optional[Any]   			=					num_labels
								__lowerCamelCase							:							Tuple   			=					num_choices
								__lowerCamelCase							:							Union[str, Any]   			=					scope
							def        lowerCAmelCase	(						self						:     List[Any]):
								__lowerCamelCase							:							List[str]   			=					ids_tensor([self.batch_size, self.seq_length]  ,self.vocab_size)

								__lowerCamelCase							:							Optional[Any]   			=					None
								if self.use_input_mask:
									__lowerCamelCase							:							Optional[int]   			=					random_attention_mask([self.batch_size, self.seq_length])

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

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

								__lowerCamelCase							:							Dict   			=					self.get_config()

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
							def        lowerCAmelCase	(						self						:     Union[str, Any]):
								return NystromformerConfig(
								    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  ,is_decoder=SCREAMING_SNAKE_CASE__  ,initializer_range=self.initializer_range  ,)
							def        lowerCAmelCase	(						self						:     Dict  ,SCREAMING_SNAKE_CASE__						:     Any  ,SCREAMING_SNAKE_CASE__						:     List[str]  ,SCREAMING_SNAKE_CASE__						:     Optional[int]  ,SCREAMING_SNAKE_CASE__						:     Tuple  ,SCREAMING_SNAKE_CASE__						:     Union[str, Any]  ,SCREAMING_SNAKE_CASE__						:     Dict  ,SCREAMING_SNAKE_CASE__						:     List[Any]):
								__lowerCamelCase							:							Tuple   			=					NystromformerModel(config=SCREAMING_SNAKE_CASE__)
								model.to(SCREAMING_SNAKE_CASE__)
								model.eval()
								__lowerCamelCase							:							Tuple   			=					model(SCREAMING_SNAKE_CASE__  ,attention_mask=SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__)
								__lowerCamelCase							:							Any   			=					model(SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__)
								__lowerCamelCase							:							str   			=					model(SCREAMING_SNAKE_CASE__)
								self.parent.assertEqual(result.last_hidden_state.shape  ,(self.batch_size, self.seq_length, self.hidden_size))
							def        lowerCAmelCase	(						self						:     Any  ,SCREAMING_SNAKE_CASE__						:     Union[str, Any]  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     Optional[int]  ,SCREAMING_SNAKE_CASE__						:     List[str]  ,SCREAMING_SNAKE_CASE__						:     Tuple  ,SCREAMING_SNAKE_CASE__						:     Dict  ,SCREAMING_SNAKE_CASE__						:     Dict):
								__lowerCamelCase							:							Dict   			=					NystromformerForMaskedLM(config=SCREAMING_SNAKE_CASE__)
								model.to(SCREAMING_SNAKE_CASE__)
								model.eval()
								__lowerCamelCase							:							str   			=					model(SCREAMING_SNAKE_CASE__  ,attention_mask=SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__  ,labels=SCREAMING_SNAKE_CASE__)
								self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.seq_length, self.vocab_size))
							def        lowerCAmelCase	(						self						:     Optional[int]  ,SCREAMING_SNAKE_CASE__						:     List[str]  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     Union[str, Any]  ,SCREAMING_SNAKE_CASE__						:     Optional[int]  ,SCREAMING_SNAKE_CASE__						:     Any  ,SCREAMING_SNAKE_CASE__						:     int  ,SCREAMING_SNAKE_CASE__						:     str):
								__lowerCamelCase							:							str   			=					NystromformerForQuestionAnswering(config=SCREAMING_SNAKE_CASE__)
								model.to(SCREAMING_SNAKE_CASE__)
								model.eval()
								__lowerCamelCase							:							int   			=					model(
								    SCREAMING_SNAKE_CASE__  ,attention_mask=SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__  ,start_positions=SCREAMING_SNAKE_CASE__  ,end_positions=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        lowerCAmelCase	(						self						:     Tuple  ,SCREAMING_SNAKE_CASE__						:     Any  ,SCREAMING_SNAKE_CASE__						:     int  ,SCREAMING_SNAKE_CASE__						:     Optional[Any]  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     Optional[Any]  ,SCREAMING_SNAKE_CASE__						:     Dict  ,SCREAMING_SNAKE_CASE__						:     Any):
								__lowerCamelCase							:							List[Any]   			=					self.num_labels
								__lowerCamelCase							:							List[str]   			=					NystromformerForSequenceClassification(SCREAMING_SNAKE_CASE__)
								model.to(SCREAMING_SNAKE_CASE__)
								model.eval()
								__lowerCamelCase							:							Optional[Any]   			=					model(SCREAMING_SNAKE_CASE__  ,attention_mask=SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__  ,labels=SCREAMING_SNAKE_CASE__)
								self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.num_labels))
							def        lowerCAmelCase	(						self						:     Union[str, Any]  ,SCREAMING_SNAKE_CASE__						:     Union[str, Any]  ,SCREAMING_SNAKE_CASE__						:     Tuple  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     Optional[int]  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     str):
								__lowerCamelCase							:							str   			=					self.num_labels
								__lowerCamelCase							:							List[str]   			=					NystromformerForTokenClassification(config=SCREAMING_SNAKE_CASE__)
								model.to(SCREAMING_SNAKE_CASE__)
								model.eval()
								__lowerCamelCase							:							Optional[Any]   			=					model(SCREAMING_SNAKE_CASE__  ,attention_mask=SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__  ,labels=SCREAMING_SNAKE_CASE__)
								self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.seq_length, self.num_labels))
							def        lowerCAmelCase	(						self						:     List[str]  ,SCREAMING_SNAKE_CASE__						:     int  ,SCREAMING_SNAKE_CASE__						:     str  ,SCREAMING_SNAKE_CASE__						:     Union[str, Any]  ,SCREAMING_SNAKE_CASE__						:     List[Any]  ,SCREAMING_SNAKE_CASE__						:     Dict  ,SCREAMING_SNAKE_CASE__						:     Optional[int]  ,SCREAMING_SNAKE_CASE__						:     Tuple):
								__lowerCamelCase							:							Optional[int]   			=					self.num_choices
								__lowerCamelCase							:							Tuple   			=					NystromformerForMultipleChoice(config=SCREAMING_SNAKE_CASE__)
								model.to(SCREAMING_SNAKE_CASE__)
								model.eval()
								__lowerCamelCase							:							Dict   			=					input_ids.unsqueeze(1).expand(-1  ,self.num_choices  ,-1).contiguous()
								__lowerCamelCase							:							str   			=					token_type_ids.unsqueeze(1).expand(-1  ,self.num_choices  ,-1).contiguous()
								__lowerCamelCase							:							Optional[int]   			=					input_mask.unsqueeze(1).expand(-1  ,self.num_choices  ,-1).contiguous()
								__lowerCamelCase							:							Union[str, Any]   			=					model(
								    SCREAMING_SNAKE_CASE__  ,attention_mask=SCREAMING_SNAKE_CASE__  ,token_type_ids=SCREAMING_SNAKE_CASE__  ,labels=SCREAMING_SNAKE_CASE__  ,)
								self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.num_choices))


							def        lowerCAmelCase	(						self						:     List[str]):
								__lowerCamelCase							:							Tuple   			=					self.prepare_config_and_inputs()
								(
								    __lowerCamelCase    
								)							:							Union[str, Any]   			=					config_and_inputs
								__lowerCamelCase							:							int   			=					{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict






@require_torch
class 			A_						(			SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				unittest.TestCase							):
							_UpperCAmelCase       :    str		 = (
							    (
							        NystromformerModel,
							        NystromformerForMaskedLM,
							        NystromformerForMultipleChoice,
							        NystromformerForQuestionAnswering,
							        NystromformerForSequenceClassification,
							        NystromformerForTokenClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							_UpperCAmelCase       :    Tuple		 = (
							    {
							        '''feature-extraction''': NystromformerModel,
							        '''fill-mask''': NystromformerForMaskedLM,
							        '''question-answering''': NystromformerForQuestionAnswering,
							        '''text-classification''': NystromformerForSequenceClassification,
							        '''token-classification''': NystromformerForTokenClassification,
							        '''zero-shot''': NystromformerForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							_UpperCAmelCase       :    List[Any]		 = False
							_UpperCAmelCase       :    Optional[int]		 = False
							def        lowerCAmelCase	(						self						:     List[Any]):
								__lowerCamelCase							:							List[Any]   			=					NystromformerModelTester(self)
								__lowerCamelCase							:							Optional[Any]   			=					ConfigTester(self  ,config_class=SCREAMING_SNAKE_CASE__  ,hidden_size=3_7)
							def        lowerCAmelCase	(						self						:     Union[str, Any]):
								self.config_tester.run_common_tests()
							def        lowerCAmelCase	(						self						:     Union[str, Any]):
								__lowerCamelCase							:							Dict   			=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__)
							def        lowerCAmelCase	(						self						:     Any):
								__lowerCamelCase							:							str   			=					self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
									__lowerCamelCase							:							List[str]   			=					type
									self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__)
							def        lowerCAmelCase	(						self						:     Union[str, Any]):
								__lowerCamelCase							:							Optional[Any]   			=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE__)
							def        lowerCAmelCase	(						self						:     Optional[Any]):
								__lowerCamelCase							:							List[str]   			=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE__)
							def        lowerCAmelCase	(						self						:     Optional[Any]):
								__lowerCamelCase							:							Dict   			=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__)
							def        lowerCAmelCase	(						self						:     Any):
								__lowerCamelCase							:							Any   			=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE__)
							def        lowerCAmelCase	(						self						:     Dict):
								__lowerCamelCase							:							Optional[int]   			=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__)


							@slow
							def        lowerCAmelCase	(						self						:     Union[str, Any]):







								for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase							:							Optional[int]   			=					NystromformerModel.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)






@require_torch
class 			A_						(			unittest.TestCase							):
							@slow
							def        lowerCAmelCase	(						self						:     Tuple):
								__lowerCamelCase							:							Tuple   			=					NystromformerModel.from_pretrained('uw-madison/nystromformer-512')
								__lowerCamelCase							:							Tuple   			=					torch.tensor([[0, 1, 2, 3, 4, 5]])

								with torch.no_grad():
									__lowerCamelCase							:							Optional[int]   			=					model(SCREAMING_SNAKE_CASE__)[0]

								__lowerCamelCase							:							Any   			=					torch.Size((1, 6, 7_6_8))
								self.assertEqual(output.shape  ,SCREAMING_SNAKE_CASE__)

								__lowerCamelCase							:							str   			=					torch.tensor(
								    [[[-0.4532, -0.0936, 0.5137], [-0.2676, 0.0628, 0.6186], [-0.3629, -0.1726, 0.4716]]])

								self.assertTrue(torch.allclose(output[:, :3, :3]  ,SCREAMING_SNAKE_CASE__  ,atol=1E-4))


							@slow
							def        lowerCAmelCase	(						self						:     str):
								__lowerCamelCase							:							Union[str, Any]   			=					'the [MASK] of Belgium is Brussels'

								__lowerCamelCase							:							Dict   			=					AutoTokenizer.from_pretrained('uw-madison/nystromformer-512')
								__lowerCamelCase							:							Dict   			=					NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512')

								__lowerCamelCase							:							Dict   			=					tokenizer(SCREAMING_SNAKE_CASE__  ,return_tensors='pt')

								with torch.no_grad():
									__lowerCamelCase							:							Dict   			=					model(encoding.input_ids).logits

								__lowerCamelCase							:							Optional[int]   			=					token_logits[:, 2, :].argmax(-1)[0]

								self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE__)  ,'capital')










'''simple docstring'''



from typing import TYPE_CHECKING

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


UpperCamelCase_    	=				{
    "configuration_roformer": ["ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "RoFormerConfig", "RoFormerOnnxConfig"],
    "tokenization_roformer": ["RoFormerTokenizer"],
}

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

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

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


