

import unittest

from transformers import MraConfig, 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, floats_tensor, ids_tensor, random_attention_mask


if is_torch_available():
 import torch

 from transformers import (
     MraForMaskedLM,
     MraForMultipleChoice,
     MraForQuestionAnswering,
     MraForSequenceClassification,
     MraForTokenClassification,
     MraModel,
 )
 from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST






class       __A :






    def __init__(		self	:			str			, UpperCAmelCase_	:			List[Any]			, UpperCAmelCase_	:			Optional[Any]=2			, UpperCAmelCase_	:			List[str]=8			, UpperCAmelCase_	:			List[Any]=True			, UpperCAmelCase_	:			int=True			, UpperCAmelCase_	:			Union[str, Any]=True			, UpperCAmelCase_	:			str=True			, UpperCAmelCase_	:			List[str]=99			, UpperCAmelCase_	:			Union[str, Any]=16			, UpperCAmelCase_	:			int=5			, UpperCAmelCase_	:			Dict=2			, UpperCAmelCase_	:			Optional[int]=36			, UpperCAmelCase_	:			Dict="gelu"			, UpperCAmelCase_	:			str=0.0			, UpperCAmelCase_	:			Optional[int]=0.0			, UpperCAmelCase_	:			Any=512			, UpperCAmelCase_	:			Union[str, Any]=16			, UpperCAmelCase_	:			Dict=2			, UpperCAmelCase_	:			Union[str, Any]=0.02			, UpperCAmelCase_	:			Tuple=3			, UpperCAmelCase_	:			Optional[int]=4			, UpperCAmelCase_	:			Tuple=None			, ):
        lowerCAmelCase :	str				=					parent
        lowerCAmelCase :	Any				=					batch_size
        lowerCAmelCase :	Optional[Any]				=					seq_length
        lowerCAmelCase :	Tuple				=					is_training
        lowerCAmelCase :	Union[str, Any]				=					use_input_mask
        lowerCAmelCase :	str				=					use_token_type_ids
        lowerCAmelCase :	int				=					use_labels
        lowerCAmelCase :	Tuple				=					vocab_size
        lowerCAmelCase :	Tuple				=					hidden_size
        lowerCAmelCase :	str				=					num_hidden_layers
        lowerCAmelCase :	Any				=					num_attention_heads
        lowerCAmelCase :	Optional[int]				=					intermediate_size
        lowerCAmelCase :	Tuple				=					hidden_act
        lowerCAmelCase :	List[str]				=					hidden_dropout_prob
        lowerCAmelCase :	List[Any]				=					attention_probs_dropout_prob
        lowerCAmelCase :	Optional[Any]				=					max_position_embeddings
        lowerCAmelCase :	List[str]				=					type_vocab_size
        lowerCAmelCase :	Dict				=					type_sequence_label_size
        lowerCAmelCase :	List[Any]				=					initializer_range
        lowerCAmelCase :	List[Any]				=					num_labels
        lowerCAmelCase :	str				=					num_choices
        lowerCAmelCase :	Tuple				=					scope






    def 		lowercase__       (		self	:			Optional[int]			):
        lowerCAmelCase :	int				=					ids_tensor([self.batch_size, self.seq_length]			, self.vocab_size			)

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

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

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

        lowerCAmelCase :	Tuple				=					self.get_config()

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






    def 		lowercase__       (		self	:			Any			):
        return MraConfig(
            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=_UpperCamelCase			, initializer_range=self.initializer_range			, )






    def 		lowercase__       (		self	:			Dict			):
        lowerCAmelCase :	Dict				=					self.get_config()
        lowerCAmelCase :	Optional[Any]				=					300
        return config






    def 		lowercase__       (		self	:			Tuple			):
        (
            (
            lowerCAmelCase  
        )	,     (
            lowerCAmelCase  
        )	,     (
            lowerCAmelCase  
        )	,     (
            lowerCAmelCase  
        )	,     (
            lowerCAmelCase  
        )	,     (
            lowerCAmelCase  
        )	,     (
            lowerCAmelCase  
        )	,       
        ) :	Dict				=					self.prepare_config_and_inputs()

        lowerCAmelCase :	Union[str, Any]				=					True
        lowerCAmelCase :	Optional[int]				=					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
        lowerCAmelCase :	List[Any]				=					ids_tensor([self.batch_size, self.seq_length]			, vocab_size=2			)

        return (
            config,
            input_ids,
            token_type_ids,
            input_mask,
            sequence_labels,
            token_labels,
            choice_labels,
            encoder_hidden_states,
            encoder_attention_mask,
        )






    def 		lowercase__       (		self	:			Dict			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			Union[str, Any]			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			str			, UpperCAmelCase_	:			Union[str, Any]			, UpperCAmelCase_	:			List[Any]			):
        lowerCAmelCase :	Tuple				=					MraModel(config=_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	Union[str, Any]				=					model(_UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			)
        lowerCAmelCase :	Optional[Any]				=					model(_UpperCamelCase			, token_type_ids=_UpperCamelCase			)
        lowerCAmelCase :	Optional[Any]				=					model(_UpperCamelCase			)
        self.parent.assertEqual(result.last_hidden_state.shape			, (self.batch_size, self.seq_length, self.hidden_size)			)






    def 		lowercase__       (		self	:			Any			, UpperCAmelCase_	:			Optional[int]			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			str			, UpperCAmelCase_	:			List[str]			, UpperCAmelCase_	:			List[Any]			, UpperCAmelCase_	:			int			, UpperCAmelCase_	:			Optional[int]			, UpperCAmelCase_	:			int			, UpperCAmelCase_	:			Any			, ):
        lowerCAmelCase :	Union[str, Any]				=					True
        lowerCAmelCase :	Dict				=					MraModel(_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	Optional[int]				=					model(
            _UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, encoder_hidden_states=_UpperCamelCase			, encoder_attention_mask=_UpperCamelCase			, )
        lowerCAmelCase :	Tuple				=					model(
            _UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, encoder_hidden_states=_UpperCamelCase			, )
        lowerCAmelCase :	int				=					model(_UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			)
        self.parent.assertEqual(result.last_hidden_state.shape			, (self.batch_size, self.seq_length, self.hidden_size)			)






    def 		lowercase__       (		self	:			List[Any]			, UpperCAmelCase_	:			Union[str, Any]			, UpperCAmelCase_	:			Optional[int]			, UpperCAmelCase_	:			Tuple			, UpperCAmelCase_	:			List[Any]			, UpperCAmelCase_	:			int			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			Optional[Any]			):
        lowerCAmelCase :	List[Any]				=					MraForMaskedLM(config=_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	Optional[int]				=					model(_UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, labels=_UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape			, (self.batch_size, self.seq_length, self.vocab_size)			)






    def 		lowercase__       (		self	:			Union[str, Any]			, UpperCAmelCase_	:			Optional[int]			, UpperCAmelCase_	:			Union[str, Any]			, UpperCAmelCase_	:			List[str]			, UpperCAmelCase_	:			Any			, UpperCAmelCase_	:			int			, UpperCAmelCase_	:			List[Any]			, UpperCAmelCase_	:			int			):
        lowerCAmelCase :	Dict				=					MraForQuestionAnswering(config=_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	Any				=					model(
            _UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, start_positions=_UpperCamelCase			, end_positions=_UpperCamelCase			, )
        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 		lowercase__       (		self	:			List[Any]			, UpperCAmelCase_	:			List[Any]			, UpperCAmelCase_	:			Optional[Any]			, UpperCAmelCase_	:			Any			, UpperCAmelCase_	:			Any			, UpperCAmelCase_	:			Tuple			, UpperCAmelCase_	:			Tuple			, UpperCAmelCase_	:			str			):
        lowerCAmelCase :	List[str]				=					self.num_labels
        lowerCAmelCase :	List[str]				=					MraForSequenceClassification(_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	Any				=					model(_UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, labels=_UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape			, (self.batch_size, self.num_labels)			)






    def 		lowercase__       (		self	:			Any			, UpperCAmelCase_	:			List[Any]			, UpperCAmelCase_	:			List[str]			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			Optional[Any]			, UpperCAmelCase_	:			Dict			, UpperCAmelCase_	:			Tuple			, UpperCAmelCase_	:			Dict			):
        lowerCAmelCase :	Optional[Any]				=					self.num_labels
        lowerCAmelCase :	Tuple				=					MraForTokenClassification(config=_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	Optional[int]				=					model(_UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, labels=_UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape			, (self.batch_size, self.seq_length, self.num_labels)			)






    def 		lowercase__       (		self	:			Optional[Any]			, UpperCAmelCase_	:			Union[str, Any]			, UpperCAmelCase_	:			Optional[Any]			, UpperCAmelCase_	:			str			, UpperCAmelCase_	:			Any			, UpperCAmelCase_	:			str			, UpperCAmelCase_	:			int			, UpperCAmelCase_	:			Optional[int]			):
        lowerCAmelCase :	List[str]				=					self.num_choices
        lowerCAmelCase :	Optional[int]				=					MraForMultipleChoice(config=_UpperCamelCase			)
        model.to(_UpperCamelCase			)
        model.eval()
        lowerCAmelCase :	int				=					input_ids.unsqueeze(1			).expand(-1			, self.num_choices			, -1			).contiguous()
        lowerCAmelCase :	List[Any]				=					token_type_ids.unsqueeze(1			).expand(-1			, self.num_choices			, -1			).contiguous()
        lowerCAmelCase :	str				=					input_mask.unsqueeze(1			).expand(-1			, self.num_choices			, -1			).contiguous()
        lowerCAmelCase :	Any				=					model(
            _UpperCamelCase			, attention_mask=_UpperCamelCase			, token_type_ids=_UpperCamelCase			, labels=_UpperCamelCase			, )
        self.parent.assertEqual(result.logits.shape			, (self.batch_size, self.num_choices)			)






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






@require_torch
class       __A (							__a  ,  unittest.TestCase       ):
    lowerCAmelCase_							:						int						 =							(
        (
            MraModel,
            MraForMaskedLM,
            MraForMultipleChoice,
            MraForQuestionAnswering,
            MraForSequenceClassification,
            MraForTokenClassification,
        )
        if is_torch_available()
        else ()
    )
    lowerCAmelCase_							:						List[Any]						 =							False
    lowerCAmelCase_							:						int						 =							False
    lowerCAmelCase_							:						Tuple						 =							False
    lowerCAmelCase_							:						Dict						 =							False

    lowerCAmelCase_							:						str						 =							()






    def 		lowercase__       (		self	:			Optional[Any]			):
        lowerCAmelCase :	int				=					MraModelTester(self			)
        lowerCAmelCase :	List[Any]				=					ConfigTester(self			, config_class=_UpperCamelCase			, hidden_size=37			)






    def 		lowercase__       (		self	:			List[Any]			):
        self.config_tester.run_common_tests()






    def 		lowercase__       (		self	:			int			):
        lowerCAmelCase :	List[Any]				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_UpperCamelCase			)






    def 		lowercase__       (		self	:			str			):
        lowerCAmelCase :	Union[str, Any]				=					self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
            lowerCAmelCase :	int				=					type
            self.model_tester.create_and_check_model(*_UpperCamelCase			)






    def 		lowercase__       (		self	:			str			):
        lowerCAmelCase :	int				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase			)






    def 		lowercase__       (		self	:			Optional[Any]			):
        lowerCAmelCase :	Union[str, Any]				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*_UpperCamelCase			)






    def 		lowercase__       (		self	:			Tuple			):
        lowerCAmelCase :	List[Any]				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase			)






    def 		lowercase__       (		self	:			Union[str, Any]			):
        lowerCAmelCase :	List[Any]				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase			)






    def 		lowercase__       (		self	:			Tuple			):
        lowerCAmelCase :	str				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase			)






    @slow
    def 		lowercase__       (		self	:			Union[str, Any]			):
        for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            lowerCAmelCase :	Union[str, Any]				=					MraModel.from_pretrained(_UpperCamelCase			)
            self.assertIsNotNone(_UpperCamelCase			)






    @unittest.skip(reason='MRA does not output attentions'			)
    def 		lowercase__       (		self	:			List[str]			):
        return






@require_torch
class       __A (							unittest.TestCase       ):






    @slow
    def 		lowercase__       (		self	:			str			):
        lowerCAmelCase :	Optional[int]				=					MraModel.from_pretrained('uw-madison/mra-base-512-4'			)
        lowerCAmelCase :	List[str]				=					torch.arange(256			).unsqueeze(0			)

        with torch.no_grad():
            lowerCAmelCase :	int				=					model(_UpperCamelCase			)[0]

        lowerCAmelCase :	Dict				=					torch.Size((1, 256, 768)			)
        self.assertEqual(output.shape			, _UpperCamelCase			)

        lowerCAmelCase :	Optional[Any]				=					torch.tensor(
            [[[-0.01_40, 0.08_30, -0.03_81], [0.15_46, 0.14_02, 0.02_20], [0.11_62, 0.08_51, 0.01_65]]]			)

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






    @slow
    def 		lowercase__       (		self	:			Optional[Any]			):
        lowerCAmelCase :	List[Any]				=					MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4'			)
        lowerCAmelCase :	List[Any]				=					torch.arange(256			).unsqueeze(0			)

        with torch.no_grad():
            lowerCAmelCase :	List[str]				=					model(_UpperCamelCase			)[0]

        lowerCAmelCase :	int				=					50265

        lowerCAmelCase :	int				=					torch.Size((1, 256, vocab_size)			)
        self.assertEqual(output.shape			, _UpperCamelCase			)

        lowerCAmelCase :	int				=					torch.tensor(
            [[[9.25_95, -3.60_38, 11.88_19], [9.38_69, -3.26_93, 11.09_56], [11.85_24, -3.49_38, 13.12_10]]]			)

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






    @slow
    def 		lowercase__       (		self	:			Tuple			):
        lowerCAmelCase :	Dict				=					MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3'			)
        lowerCAmelCase :	Dict				=					torch.arange(4096			).unsqueeze(0			)

        with torch.no_grad():
            lowerCAmelCase :	str				=					model(_UpperCamelCase			)[0]

        lowerCAmelCase :	Any				=					50265

        lowerCAmelCase :	List[Any]				=					torch.Size((1, 4096, vocab_size)			)
        self.assertEqual(output.shape			, _UpperCamelCase			)

        lowerCAmelCase :	Dict				=					torch.tensor(
            [[[5.47_89, -2.35_64, 7.50_64], [7.90_67, -1.33_69, 9.96_68], [9.07_12, -1.81_06, 7.03_80]]]			)

        self.assertTrue(torch.allclose(output[:, :3, :3]			, _UpperCamelCase			, 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,
)


_A   =     {
    "configuration_distilbert": [
        "DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "DistilBertConfig",
        "DistilBertOnnxConfig",
    ],
    "tokenization_distilbert": ["DistilBertTokenizer"],
}

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

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     [
			    "DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "DistilBertForMaskedLM",
			    "DistilBertForMultipleChoice",
			    "DistilBertForQuestionAnswering",
			    "DistilBertForSequenceClassification",
			    "DistilBertForTokenClassification",
			    "DistilBertModel",
			    "DistilBertPreTrainedModel",
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     [
			    "TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "TFDistilBertForMaskedLM",
			    "TFDistilBertForMultipleChoice",
			    "TFDistilBertForQuestionAnswering",
			    "TFDistilBertForSequenceClassification",
			    "TFDistilBertForTokenClassification",
			    "TFDistilBertMainLayer",
			    "TFDistilBertModel",
			    "TFDistilBertPreTrainedModel",
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     [
			    "FlaxDistilBertForMaskedLM",
			    "FlaxDistilBertForMultipleChoice",
			    "FlaxDistilBertForQuestionAnswering",
			    "FlaxDistilBertForSequenceClassification",
			    "FlaxDistilBertForTokenClassification",
			    "FlaxDistilBertModel",
			    "FlaxDistilBertPreTrainedModel",
			]


if TYPE_CHECKING:
			from .configuration_distilbert import (
			    DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    DistilBertConfig,
			    DistilBertOnnxConfig,
			)
			from .tokenization_distilbert import DistilBertTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_distilbert_fast import DistilBertTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_distilbert import (
						    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    DistilBertForMaskedLM,
						    DistilBertForMultipleChoice,
						    DistilBertForQuestionAnswering,
						    DistilBertForSequenceClassification,
						    DistilBertForTokenClassification,
						    DistilBertModel,
						    DistilBertPreTrainedModel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_distilbert import (
						    TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFDistilBertForMaskedLM,
						    TFDistilBertForMultipleChoice,
						    TFDistilBertForQuestionAnswering,
						    TFDistilBertForSequenceClassification,
						    TFDistilBertForTokenClassification,
						    TFDistilBertMainLayer,
						    TFDistilBertModel,
						    TFDistilBertPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_flax_distilbert import (
						    FlaxDistilBertForMaskedLM,
						    FlaxDistilBertForMultipleChoice,
						    FlaxDistilBertForQuestionAnswering,
						    FlaxDistilBertForSequenceClassification,
						    FlaxDistilBertForTokenClassification,
						    FlaxDistilBertModel,
						    FlaxDistilBertPreTrainedModel,
						)

else:
			import sys

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



