
"""simple docstring"""




import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
					import torch
					from torch import nn

					from transformers import (
					    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
					    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
					    MODEL_MAPPING,
					    DeiTForImageClassification,
					    DeiTForImageClassificationWithTeacher,
					    DeiTForMaskedImageModeling,
					    DeiTModel,
					)
					from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import DeiTImageProcessor



class 	lowerCAmelCase_						:


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__=13   ,       SCREAMING_SNAKE_CASE__=30   ,       SCREAMING_SNAKE_CASE__=2   ,       SCREAMING_SNAKE_CASE__=3   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=32   ,       SCREAMING_SNAKE_CASE__=5   ,       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__=10   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=3   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=2   ,       )					->		Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       str           =   parent
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   batch_size
											SCREAMING_SNAKE_CASE__						:       Any           =   image_size
											SCREAMING_SNAKE_CASE__						:       Tuple           =   patch_size
											SCREAMING_SNAKE_CASE__						:       Tuple           =   num_channels
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   is_training
											SCREAMING_SNAKE_CASE__						:       List[str]           =   use_labels
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_size
											SCREAMING_SNAKE_CASE__						:       Any           =   num_hidden_layers
											SCREAMING_SNAKE_CASE__						:       int           =   num_attention_heads
											SCREAMING_SNAKE_CASE__						:       Dict           =   intermediate_size
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_act
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_dropout_prob
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE__						:       int           =   type_sequence_label_size
											SCREAMING_SNAKE_CASE__						:       List[str]           =   initializer_range
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   scope
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   encoder_stride

											# in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   (image_size // patch_size) ** 2
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   num_patches + 2



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

											SCREAMING_SNAKE_CASE__						:       List[str]           =   None
											if self.use_labels:
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   ids_tensor([self.batch_size]   ,       self.type_sequence_label_size    )

											SCREAMING_SNAKE_CASE__						:       int           =   self.get_config()

											return config, pixel_values, labels



				def 	__magic_name__    (self    )					->		str:



											"""simple docstring"""




											return DeiTConfig(
											    image_size=self.image_size   ,       patch_size=self.patch_size   ,       num_channels=self.num_channels   ,       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   ,       is_decoder=SCREAMING_SNAKE_CASE__   ,       initializer_range=self.initializer_range   ,       encoder_stride=self.encoder_stride   ,       )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Dict           =   DeiTModel(config=SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											SCREAMING_SNAKE_CASE__						:       int           =   model(SCREAMING_SNAKE_CASE__    )
											self.parent.assertEqual(result.last_hidden_state.shape   ,       (self.batch_size, self.seq_length, self.hidden_size)    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   DeiTForMaskedImageModeling(config=SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											SCREAMING_SNAKE_CASE__						:       List[str]           =   model(SCREAMING_SNAKE_CASE__    )
											self.parent.assertEqual(
											    result.reconstruction.shape   ,       (self.batch_size, self.num_channels, self.image_size, self.image_size)    )

											# test greyscale images
											SCREAMING_SNAKE_CASE__						:       int           =   1
											SCREAMING_SNAKE_CASE__						:       List[str]           =   DeiTForMaskedImageModeling(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()

											SCREAMING_SNAKE_CASE__						:       Tuple           =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   model(SCREAMING_SNAKE_CASE__    )
											self.parent.assertEqual(result.reconstruction.shape   ,       (self.batch_size, 1, self.image_size, self.image_size)    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   self.type_sequence_label_size
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   DeiTForImageClassification(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											SCREAMING_SNAKE_CASE__						:       int           =   model(SCREAMING_SNAKE_CASE__   ,       labels=SCREAMING_SNAKE_CASE__    )
											self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.type_sequence_label_size)    )

											# test greyscale images
											SCREAMING_SNAKE_CASE__						:       Tuple           =   1
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   DeiTForImageClassification(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()

											SCREAMING_SNAKE_CASE__						:       Dict           =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
											SCREAMING_SNAKE_CASE__						:       str           =   model(SCREAMING_SNAKE_CASE__   ,       labels=SCREAMING_SNAKE_CASE__    )
											self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.type_sequence_label_size)    )



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   self.prepare_config_and_inputs()
											(
											    (
											    SCREAMING_SNAKE_CASE__
											)      ,      (
											    SCREAMING_SNAKE_CASE__
											)      ,      (
											    SCREAMING_SNAKE_CASE__
											)      ,      
											)						:       List[Any]           =   config_and_inputs
											SCREAMING_SNAKE_CASE__						:       List[str]           =   {"""pixel_values""": pixel_values}
											return config, inputs_dict






@require_torch
class 	lowerCAmelCase_						(a__ ,					a__ ,					unittest.TestCase  ):


				"""simple docstring"""



				__UpperCamelCase      :						Any					       =   (
				    (
				        DeiTModel,
				        DeiTForImageClassification,
				        DeiTForImageClassificationWithTeacher,
				        DeiTForMaskedImageModeling,
				    )
				    if is_torch_available()
				    else ()
				)
				__UpperCamelCase      :						List[str]					       =   (
				    {
				        '''feature-extraction''': DeiTModel,
				        '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
				    }
				    if is_torch_available()
				    else {}
				)

				__UpperCamelCase      :						List[Any]					       =   False
				__UpperCamelCase      :						Union[str, Any]					       =   False
				__UpperCamelCase      :						Tuple					       =   False



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[Any]           =   DeiTModelTester(self    )
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   ConfigTester(self   ,       config_class=SCREAMING_SNAKE_CASE__   ,       has_text_modality=SCREAMING_SNAKE_CASE__   ,       hidden_size=37    )



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



											"""simple docstring"""




											self.config_tester.run_common_tests()



				@unittest.skip(reason="""DeiT does not use inputs_embeds"""    )
				def 	__magic_name__    (self    )					->		List[Any]:



											"""simple docstring"""




											pass



				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE__						:       Any           =   model_class(SCREAMING_SNAKE_CASE__    )
																		self.assertIsInstance(model.get_input_embeddings()   ,       (nn.Module)    )
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   model.get_output_embeddings()
																		self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__   ,       nn.Linear    )    )



				def 	__magic_name__    (self    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       List[str]           =   self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE__						:       int           =   model_class(SCREAMING_SNAKE_CASE__    )
																		SCREAMING_SNAKE_CASE__						:       int           =   inspect.signature(model.forward    )
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   [*signature.parameters.keys()]

																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   ["""pixel_values"""]
																		self.assertListEqual(arg_names[:1]   ,       SCREAMING_SNAKE_CASE__    )



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Dict           =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__=False    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   super()._prepare_for_class(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       return_labels=SCREAMING_SNAKE_CASE__    )

											if return_labels:
																		if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																									del inputs_dict["labels"]

											return inputs_dict



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



											"""simple docstring"""




											if not self.model_tester.is_training:
																		return

											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Any           =   self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   True

											for model_class in self.all_model_classes:
																		# DeiTForImageClassificationWithTeacher supports inference-only
																		if (
																		    model_class in get_values(SCREAMING_SNAKE_CASE__    )
																		    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																		):
																									continue
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   model_class(SCREAMING_SNAKE_CASE__    )
																		model.to(SCREAMING_SNAKE_CASE__    )
																		model.train()
																		SCREAMING_SNAKE_CASE__						:       Any           =   self._prepare_for_class(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       return_labels=SCREAMING_SNAKE_CASE__    )
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   model(**SCREAMING_SNAKE_CASE__    ).loss
																		loss.backward()



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       List[str]           =   self.model_tester.prepare_config_and_inputs_for_common()
											if not self.model_tester.is_training:
																		return

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   False
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   True

											for model_class in self.all_model_classes:
																		if model_class in get_values(SCREAMING_SNAKE_CASE__    ) or not model_class.supports_gradient_checkpointing:
																									continue
																		# DeiTForImageClassificationWithTeacher supports inference-only
																		if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																									continue
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   model_class(SCREAMING_SNAKE_CASE__    )
																		model.gradient_checkpointing_enable()
																		model.to(SCREAMING_SNAKE_CASE__    )
																		model.train()
																		SCREAMING_SNAKE_CASE__						:       int           =   self._prepare_for_class(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       return_labels=SCREAMING_SNAKE_CASE__    )
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   model(**SCREAMING_SNAKE_CASE__    ).loss
																		loss.backward()



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   self.model_tester.prepare_config_and_inputs_for_common()

											SCREAMING_SNAKE_CASE__						:       int           =   [
											    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
											    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
											    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
											]

											for model_class in self.all_model_classes:
																		if (
																		    model_class
																		    not in [
																		        *get_values(SCREAMING_SNAKE_CASE__    ),
																		        *get_values(SCREAMING_SNAKE_CASE__    ),
																		    ]
																		    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																		):
																									continue

																		for problem_type in problem_types:
																									with self.subTest(msg=F'''Testing {model_class} with {problem_type['title']}'''    ):
																																SCREAMING_SNAKE_CASE__						:       Dict           =   problem_type["""title"""]
																																SCREAMING_SNAKE_CASE__						:       List[Any]           =   problem_type["""num_labels"""]

																																SCREAMING_SNAKE_CASE__						:       Dict           =   model_class(SCREAMING_SNAKE_CASE__    )
																																model.to(SCREAMING_SNAKE_CASE__    )
																																model.train()

																																SCREAMING_SNAKE_CASE__						:       List[Any]           =   self._prepare_for_class(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       return_labels=SCREAMING_SNAKE_CASE__    )

																																if problem_type["num_labels"] > 1:
																																							SCREAMING_SNAKE_CASE__						:       List[str]           =   inputs["""labels"""].unsqueeze(1    ).repeat(1   ,       problem_type["""num_labels"""]    )

																																SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   inputs["""labels"""].to(problem_type["""dtype"""]    )

																																# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																																# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																																# they have the same size." which is a symptom something in wrong for the regression problem.
																																# See https://github.com/huggingface/transformers/issues/11780
																																with warnings.catch_warnings(record=SCREAMING_SNAKE_CASE__    ) as warning_list:
																																							SCREAMING_SNAKE_CASE__						:       List[Any]           =   model(**SCREAMING_SNAKE_CASE__    ).loss
																																for w in warning_list:
																																							if "Using a target size that is different to the input size" in str(w.message    ):
																																														raise ValueError(
																																														    F'''Something is going wrong in the regression problem: intercepted {w.message}'''    )

																																loss.backward()



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



											"""simple docstring"""




											for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   DeiTModel.from_pretrained(SCREAMING_SNAKE_CASE__    )
																		self.assertIsNotNone(SCREAMING_SNAKE_CASE__    )






def lowercase_  (   ):
							SCREAMING_SNAKE_CASE__						:       int           =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
							return image



@require_torch
@require_vision
class 	lowerCAmelCase_						(unittest.TestCase  ):


				"""simple docstring"""



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



											"""simple docstring"""




											return (
											    DeiTImageProcessor.from_pretrained("""facebook/deit-base-distilled-patch16-224"""    )
											    if is_vision_available()
											    else None
											)



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   DeiTForImageClassificationWithTeacher.from_pretrained("""facebook/deit-base-distilled-patch16-224"""    ).to(
											    SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.default_image_processor
											SCREAMING_SNAKE_CASE__						:       str           =   prepare_img()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   image_processor(images=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    ).to(SCREAMING_SNAKE_CASE__    )

											# forward pass
											with torch.no_grad():
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   model(**SCREAMING_SNAKE_CASE__    )

											# verify the logits
											SCREAMING_SNAKE_CASE__						:       Tuple           =   torch.Size((1, 10_00)    )
											self.assertEqual(outputs.logits.shape   ,       SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       List[str]           =   torch.tensor([-1.0266, 0.1912, -1.2861]    ).to(SCREAMING_SNAKE_CASE__    )

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



				@slow
				@require_accelerate
				@require_torch_gpu
				def 	__magic_name__    (self    )					->		Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   DeiTModel.from_pretrained(
											    """facebook/deit-base-distilled-patch16-224"""   ,       torch_dtype=torch.floataa   ,       device_map="""auto"""    )
											SCREAMING_SNAKE_CASE__						:       Any           =   self.default_image_processor

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   prepare_img()
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   image_processor(images=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    )
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   inputs.pixel_values.to(SCREAMING_SNAKE_CASE__    )

											# forward pass to make sure inference works in fp16
											with torch.no_grad():
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   model(SCREAMING_SNAKE_CASE__    )






'''simple docstring'''







from typing import TYPE_CHECKING

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


lowercase    :							Tuple      =					{
    "configuration_xlm": ["XLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMConfig", "XLMOnnxConfig"],
    "tokenization_xlm": ["XLMTokenizer"],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase    :							int      =					[
					    "XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "XLMForMultipleChoice",
					    "XLMForQuestionAnswering",
					    "XLMForQuestionAnsweringSimple",
					    "XLMForSequenceClassification",
					    "XLMForTokenClassification",
					    "XLMModel",
					    "XLMPreTrainedModel",
					    "XLMWithLMHeadModel",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase    :							Tuple      =					[
					    "TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TFXLMForMultipleChoice",
					    "TFXLMForQuestionAnsweringSimple",
					    "TFXLMForSequenceClassification",
					    "TFXLMForTokenClassification",
					    "TFXLMMainLayer",
					    "TFXLMModel",
					    "TFXLMPreTrainedModel",
					    "TFXLMWithLMHeadModel",
					]


if TYPE_CHECKING:
					from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
					from .tokenization_xlm import XLMTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm import (
										    XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMForMultipleChoice,
										    XLMForQuestionAnswering,
										    XLMForQuestionAnsweringSimple,
										    XLMForSequenceClassification,
										    XLMForTokenClassification,
										    XLMModel,
										    XLMPreTrainedModel,
										    XLMWithLMHeadModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_xlm import (
										    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFXLMForMultipleChoice,
										    TFXLMForQuestionAnsweringSimple,
										    TFXLMForSequenceClassification,
										    TFXLMForTokenClassification,
										    TFXLMMainLayer,
										    TFXLMModel,
										    TFXLMPreTrainedModel,
										    TFXLMWithLMHeadModel,
										)

else:
					import sys

					lowercase    :							Union[str, Any]      =					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

