


'''simple docstring'''



from __future__ import annotations

import inspect
import unittest

from transformers import MobileViTConfig
from transformers.file_utils import is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import numpy as np
      import tensorflow as tf

      from transformers import TFMobileViTForImageClassification, TFMobileViTForSemanticSegmentation, TFMobileViTModel
      from transformers.models.mobilevit.modeling_tf_mobilevit import TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import MobileViTImageProcessor



class       a							(						A_			):


     """simple docstring"""






     def 					lowerCamelCase__					(							self	:						str     )		->				List[Any]:
          __UpperCAmelCase      :					Optional[Any]    				=     self.config_class(**self.inputs_dict     )
          self.parent.assertTrue(hasattr(__lowercase				,					'''hidden_sizes'''     )     )
          self.parent.assertTrue(hasattr(__lowercase				,					'''neck_hidden_sizes'''     )     )
          self.parent.assertTrue(hasattr(__lowercase				,					'''num_attention_heads'''     )     )



class       a							:


     """simple docstring"""






     def __init__(							self	:						Union[str, Any]				,					snake_case	:						Dict				,					snake_case	:						Any=13				,					snake_case	:						List[str]=32				,					snake_case	:						List[str]=2				,					snake_case	:						Optional[int]=3				,					snake_case	:						Dict=640				,					snake_case	:						Union[str, Any]=4				,					snake_case	:						int="silu"				,					snake_case	:						Dict=3				,					snake_case	:						int=32				,					snake_case	:						int=0.1				,					snake_case	:						Optional[int]=0.1				,					snake_case	:						Optional[Any]=0.1				,					snake_case	:						Tuple=0.02				,					snake_case	:						str=True				,					snake_case	:						str=True				,					snake_case	:						Optional[int]=10				,					snake_case	:						List[Any]=None				,					)		->				str:
          __UpperCAmelCase      :					str    				=     parent
          __UpperCAmelCase      :					List[Any]    				=     batch_size
          __UpperCAmelCase      :					Tuple    				=     image_size
          __UpperCAmelCase      :					Any    				=     patch_size
          __UpperCAmelCase      :					Optional[int]    				=     num_channels
          __UpperCAmelCase      :					Optional[Any]    				=     last_hidden_size
          __UpperCAmelCase      :					List[str]    				=     num_attention_heads
          __UpperCAmelCase      :					Dict    				=     hidden_act
          __UpperCAmelCase      :					List[Any]    				=     conv_kernel_size
          __UpperCAmelCase      :					List[str]    				=     output_stride
          __UpperCAmelCase      :					Any    				=     hidden_dropout_prob
          __UpperCAmelCase      :					Optional[Any]    				=     attention_probs_dropout_prob
          __UpperCAmelCase      :					Dict    				=     classifier_dropout_prob
          __UpperCAmelCase      :					List[str]    				=     use_labels
          __UpperCAmelCase      :					List[str]    				=     is_training
          __UpperCAmelCase      :					int    				=     num_labels
          __UpperCAmelCase      :					Union[str, Any]    				=     initializer_range
          __UpperCAmelCase      :					int    				=     scope

     def 					lowerCamelCase__					(							self	:						List[Any]     )		->				Union[str, Any]:
          __UpperCAmelCase      :					Optional[Any]    				=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

          __UpperCAmelCase      :					List[str]    				=     None
          __UpperCAmelCase      :					str    				=     None
          if self.use_labels:
               __UpperCAmelCase      :					str    				=     ids_tensor([self.batch_size]				,					self.num_labels     )
               __UpperCAmelCase      :					List[str]    				=     ids_tensor([self.batch_size, self.image_size, self.image_size]				,					self.num_labels     )

          __UpperCAmelCase      :					List[Any]    				=     self.get_config()

          return config, pixel_values, labels, pixel_labels

     def 					lowerCamelCase__					(							self	:						Any     )		->				Any:
          return MobileViTConfig(
              image_size=self.image_size				,					patch_size=self.patch_size				,					num_channels=self.num_channels				,					num_attention_heads=self.num_attention_heads				,					hidden_act=self.hidden_act				,					conv_kernel_size=self.conv_kernel_size				,					output_stride=self.output_stride				,					hidden_dropout_prob=self.hidden_dropout_prob				,					attention_probs_dropout_prob=self.attention_probs_dropout_prob				,					classifier_dropout_prob=self.classifier_dropout_prob				,					initializer_range=self.initializer_range				,					)

     def 					lowerCamelCase__					(							self	:						Any				,					snake_case	:						int				,					snake_case	:						Dict				,					snake_case	:						List[str]				,					snake_case	:						Union[str, Any]     )		->				Dict:
          __UpperCAmelCase      :					Optional[Any]    				=     TFMobileViTModel(config=__lowercase     )
          __UpperCAmelCase      :					List[str]    				=     model(__lowercase				,					training=__lowercase     )
          __UpperCAmelCase      :					Dict    				=     self.image_size // self.output_stride
          self.parent.assertEqual(
              result.last_hidden_state.shape				,					(self.batch_size, self.last_hidden_size, expected_height, expected_width)     )

     def 					lowerCamelCase__					(							self	:						int				,					snake_case	:						int				,					snake_case	:						Optional[Any]				,					snake_case	:						Dict				,					snake_case	:						Tuple     )		->				str:
          __UpperCAmelCase      :					List[Any]    				=     self.num_labels
          __UpperCAmelCase      :					Optional[Any]    				=     TFMobileViTForImageClassification(__lowercase     )
          __UpperCAmelCase      :					Tuple    				=     model(__lowercase				,					labels=__lowercase				,					training=__lowercase     )
          self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.num_labels)     )

     def 					lowerCamelCase__					(							self	:						List[str]				,					snake_case	:						Dict				,					snake_case	:						Any				,					snake_case	:						Any				,					snake_case	:						Dict     )		->				Dict:
          __UpperCAmelCase      :					List[str]    				=     self.num_labels
          __UpperCAmelCase      :					Any    				=     TFMobileViTForSemanticSegmentation(__lowercase     )
          __UpperCAmelCase      :					str    				=     self.image_size // self.output_stride

          __UpperCAmelCase      :					Union[str, Any]    				=     model(__lowercase				,					training=__lowercase     )
          self.parent.assertEqual(
              result.logits.shape				,					(self.batch_size, self.num_labels, expected_height, expected_width)     )

          __UpperCAmelCase      :					str    				=     model(__lowercase				,					labels=__lowercase				,					training=__lowercase     )
          self.parent.assertEqual(
              result.logits.shape				,					(self.batch_size, self.num_labels, expected_height, expected_width)     )






     def 					lowerCamelCase__					(							self	:						Optional[Any]     )		->				str:
          __UpperCAmelCase      :					List[Any]    				=     self.prepare_config_and_inputs()
          __UpperCAmelCase				,  __UpperCAmelCase				,  __UpperCAmelCase				,  __UpperCAmelCase      :					List[Any]    				=     config_and_inputs
          __UpperCAmelCase      :					Tuple    				=     {'''pixel_values''': pixel_values}
          return config, inputs_dict



@require_tf
class       a							(						A_      ,    A_      ,    unittest.TestCase			):


     """simple docstring"""






     SCREAMING_SNAKE_CASE			:					Optional[Any]				  =  (
         (TFMobileViTModel, TFMobileViTForImageClassification, TFMobileViTForSemanticSegmentation)
         if is_tf_available()
         else ()
     )
     SCREAMING_SNAKE_CASE			:					Optional[int]				  =  (
         {'feature-extraction': TFMobileViTModel, 'image-classification': TFMobileViTForImageClassification}
         if is_tf_available()
         else {}
     )

     SCREAMING_SNAKE_CASE			:					Union[str, Any]				  =  False
     SCREAMING_SNAKE_CASE			:					Dict				  =  False
     SCREAMING_SNAKE_CASE			:					Union[str, Any]				  =  False
     SCREAMING_SNAKE_CASE			:					List[Any]				  =  False
     SCREAMING_SNAKE_CASE			:					Union[str, Any]				  =  False

     def 					lowerCamelCase__					(							self	:						int     )		->				Any:
          __UpperCAmelCase      :					List[str]    				=     TFMobileViTModelTester(self     )
          __UpperCAmelCase      :					Dict    				=     TFMobileViTConfigTester(self				,					config_class=__lowercase				,					has_text_modality=__lowercase     )

     def 					lowerCamelCase__					(							self	:						Optional[Any]     )		->				str:
          self.config_tester.run_common_tests()

     @unittest.skip(reason='''MobileViT does not use inputs_embeds'''     )
     def 					lowerCamelCase__					(							self	:						List[str]     )		->				Optional[Any]:
          pass

     @unittest.skip(reason='''MobileViT does not support input and output embeddings'''     )
     def 					lowerCamelCase__					(							self	:						Optional[int]     )		->				Optional[int]:
          pass

     @unittest.skip(reason='''MobileViT does not output attentions'''     )
     def 					lowerCamelCase__					(							self	:						Dict     )		->				Any:
          pass

     def 					lowerCamelCase__					(							self	:						Optional[int]     )		->				Union[str, Any]:
          __UpperCAmelCase				,  __UpperCAmelCase      :					Dict    				=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __UpperCAmelCase      :					List[str]    				=     model_class(__lowercase     )
               __UpperCAmelCase      :					List[Any]    				=     inspect.signature(model.call     )
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               __UpperCAmelCase      :					List[str]    				=     [*signature.parameters.keys()]

               __UpperCAmelCase      :					List[str]    				=     ['''pixel_values''']
               self.assertListEqual(arg_names[:1]				,					__lowercase     )

     def 					lowerCamelCase__					(							self	:						List[str]     )		->				Tuple:
          __UpperCAmelCase      :					str    				=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*__lowercase     )

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







          def check_hidden_states_output(snake_case	:						Any				,					snake_case	:						str				,					snake_case	:						List[str]     ):
               __UpperCAmelCase      :					int    				=     model_class(__lowercase     )

               __UpperCAmelCase      :					Tuple    				=     model(**self._prepare_for_class(__lowercase				,					__lowercase     )     )

               __UpperCAmelCase      :					Any    				=     outputs.hidden_states

               __UpperCAmelCase      :					List[Any]    				=     5
               self.assertEqual(len(__lowercase     )				,					__lowercase     )

               # MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
               # with the width and height being successively divided by 2.
               __UpperCAmelCase      :					Tuple    				=     2
               for i in range(len(__lowercase     )     ):
                    self.assertListEqual(
                        list(hidden_states[i].shape[-2:]     )				,					[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]				,					)
                    divisor *= 2

               self.assertEqual(self.model_tester.output_stride				,					divisor // 2     )

          __UpperCAmelCase				,  __UpperCAmelCase      :					Optional[Any]    				=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __UpperCAmelCase      :					Dict    				=     True
               check_hidden_states_output(__lowercase				,					__lowercase				,					__lowercase     )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               __UpperCAmelCase      :					Tuple    				=     True

               check_hidden_states_output(__lowercase				,					__lowercase				,					__lowercase     )

     def 					lowerCamelCase__					(							self	:						Optional[Any]     )		->				List[str]:
          __UpperCAmelCase      :					Tuple    				=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*__lowercase     )

     def 					lowerCamelCase__					(							self	:						Union[str, Any]     )		->				Optional[Any]:
          __UpperCAmelCase      :					int    				=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_semantic_segmentation(*__lowercase     )

     @unittest.skipIf(
         not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''     )     ) == 0				,					reason='''TF does not support backprop for grouped convolutions on CPU.'''				,					)
     def 					lowerCamelCase__					(							self	:						str     )		->				Tuple:
          super().test_dataset_conversion()

     def 					lowerCamelCase__					(							self	:						int				,					snake_case	:						Dict				,					snake_case	:						List[Any]				,					snake_case	:						Dict=2E-1				,					snake_case	:						Any=2E-1     )		->				Union[str, Any]:
          self.assertTrue(np.allclose(__lowercase				,					__lowercase				,					atol=__lowercase				,					rtol=__lowercase     )     )

     @unittest.skipIf(
         not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''     )     ) == 0				,					reason='''TF does not support backprop for grouped convolutions on CPU.'''				,					)
     @slow
     def 					lowerCamelCase__					(							self	:						str     )		->				List[str]:
          __UpperCAmelCase				,  __UpperCAmelCase      :					Union[str, Any]    				=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               # Since `TFMobileViTModel` cannot operate with the default `fit()` method.
               if model_class.__name__ != "TFMobileViTModel":
                    __UpperCAmelCase      :					Optional[int]    				=     model_class(__lowercase     )
                    if getattr(__lowercase				,					'''hf_compute_loss'''				,					__lowercase     ):
                         super().test_keras_fit()

     def 					lowerCamelCase__					(							self	:						Optional[Any]     )		->				Optional[int]:
          __UpperCAmelCase				,  __UpperCAmelCase      :					Union[str, Any]    				=     self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes:
               # set an ignore index to correctly test the masked loss used in
               # `TFMobileViTForSemanticSegmentation`.
               if model_class.__name__ != "TFMobileViTForSemanticSegmentation":
                    __UpperCAmelCase      :					List[str]    				=     5

               __UpperCAmelCase      :					int    				=     model_class(__lowercase     )
               if getattr(__lowercase				,					'''hf_compute_loss'''				,					__lowercase     ):
                    # The number of elements in the loss should be the same as the number of elements in the label
                    __UpperCAmelCase      :					Union[str, Any]    				=     self._prepare_for_class(inputs_dict.copy()				,					__lowercase				,					return_labels=__lowercase     )
                    __UpperCAmelCase      :					Tuple    				=     prepared_for_class[
                        sorted(prepared_for_class.keys() - inputs_dict.keys()				,					reverse=__lowercase     )[0]
                    ]
                    __UpperCAmelCase      :					str    				=     added_label.shape.as_list()[:1]

                    # Test that model correctly compute the loss with kwargs
                    __UpperCAmelCase      :					Any    				=     self._prepare_for_class(inputs_dict.copy()				,					__lowercase				,					return_labels=__lowercase     )
                    __UpperCAmelCase      :					int    				=     {'''input_ids''', '''pixel_values''', '''input_features'''}
                    __UpperCAmelCase      :					List[str]    				=     possible_input_names.intersection(set(__lowercase     )     ).pop()
                    __UpperCAmelCase      :					Dict    				=     prepared_for_class.pop(__lowercase     )

                    __UpperCAmelCase      :					List[Any]    				=     model(__lowercase				,					**__lowercase     )[0]
                    self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]     )

                    # Test that model correctly compute the loss when we mask some positions
                    __UpperCAmelCase      :					str    				=     self._prepare_for_class(inputs_dict.copy()				,					__lowercase				,					return_labels=__lowercase     )
                    __UpperCAmelCase      :					Union[str, Any]    				=     {'''input_ids''', '''pixel_values''', '''input_features'''}
                    __UpperCAmelCase      :					Optional[Any]    				=     possible_input_names.intersection(set(__lowercase     )     ).pop()
                    __UpperCAmelCase      :					str    				=     prepared_for_class.pop(__lowercase     )
                    if "labels" in prepared_for_class:
                         __UpperCAmelCase      :					int    				=     prepared_for_class['''labels'''].numpy()
                         if len(labels.shape     ) > 1 and labels.shape[1] != 1:
                              # labels[0] = -100
                              __UpperCAmelCase      :					Tuple    				=     tf.convert_to_tensor(__lowercase     )
                              __UpperCAmelCase      :					Union[str, Any]    				=     model(__lowercase				,					**__lowercase     )[0]
                              self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]     )
                              self.assertTrue(not np.any(np.isnan(loss.numpy()     )     )     )

                # Test that model correctly compute the loss with a dict
                    __UpperCAmelCase      :					Optional[Any]    				=     self._prepare_for_class(inputs_dict.copy()				,					__lowercase				,					return_labels=__lowercase     )
                    __UpperCAmelCase      :					List[str]    				=     model(__lowercase     )[0]
                    self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]     )

                    # Test that model correctly compute the loss with a tuple
                    __UpperCAmelCase      :					Any    				=     self._prepare_for_class(inputs_dict.copy()				,					__lowercase				,					return_labels=__lowercase     )

                    # Get keys that were added with the _prepare_for_class function
                    __UpperCAmelCase      :					List[Any]    				=     prepared_for_class.keys() - inputs_dict.keys()
                    __UpperCAmelCase      :					Union[str, Any]    				=     inspect.signature(model.call     ).parameters
                    __UpperCAmelCase      :					Union[str, Any]    				=     list(signature.keys()     )

                    # Create a dictionary holding the location of the tensors in the tuple
                    __UpperCAmelCase      :					Union[str, Any]    				=     {0: input_name}
                    for label_key in label_keys:
                         __UpperCAmelCase      :					Union[str, Any]    				=     signature_names.index(__lowercase     )
                         __UpperCAmelCase      :					int    				=     label_key
                    __UpperCAmelCase      :					List[Any]    				=     sorted(tuple_index_mapping.items()     )
                    # Initialize a list with their default values, update the values and convert to a tuple
                    __UpperCAmelCase      :					Dict    				=     []

                    for name in signature_names:
                         if name != "kwargs":
                              list_input.append(signature[name].default     )

                    for index, value in sorted_tuple_index_mapping:
                         __UpperCAmelCase      :					Any    				=     prepared_for_class[value]

                    __UpperCAmelCase      :					List[Any]    				=     tuple(__lowercase     )

                    # Send to model
                    __UpperCAmelCase      :					Any    				=     model(tuple_input[:-1]     )[0]

                    self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]     )






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







          for model_name in TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __UpperCAmelCase      :					Union[str, Any]    				=     TFMobileViTModel.from_pretrained(__lowercase     )
               self.assertIsNotNone(__lowercase     )




def       _a      (		):





     '''simple docstring'''






     __UpperCAmelCase      :					Optional[Any]    				=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
     return image



@require_tf
class       a							(						unittest.TestCase			):


     """simple docstring"""






     @slow
     def 					lowerCamelCase__					(							self	:						Any     )		->				Any:
          __UpperCAmelCase      :					Any    				=     TFMobileViTForImageClassification.from_pretrained('''apple/mobilevit-xx-small'''     )

          __UpperCAmelCase      :					Any    				=     MobileViTImageProcessor.from_pretrained('''apple/mobilevit-xx-small'''     )
          __UpperCAmelCase      :					int    				=     prepare_img()
          __UpperCAmelCase      :					int    				=     image_processor(images=__lowercase				,					return_tensors='''tf'''     )

          # forward pass
          __UpperCAmelCase      :					Optional[int]    				=     model(**__lowercase				,					training=__lowercase     )

          # verify the logits
          __UpperCAmelCase      :					Dict    				=     tf.TensorShape((1, 1000)     )
          self.assertEqual(outputs.logits.shape				,					__lowercase     )

          __UpperCAmelCase      :					int    				=     tf.constant([-1.9_364, -1.2_327, -0.4_653]     )

          tf.debugging.assert_near(outputs.logits[0, :3]				,					__lowercase				,					atol=1E-4				,					rtol=1E-04     )






     @slow
     def 					lowerCamelCase__					(							self	:						Optional[Any]     )		->				List[Any]:
          __UpperCAmelCase      :					Tuple    				=     TFMobileViTForSemanticSegmentation.from_pretrained('''apple/deeplabv3-mobilevit-xx-small'''     )

          __UpperCAmelCase      :					List[str]    				=     MobileViTImageProcessor.from_pretrained('''apple/deeplabv3-mobilevit-xx-small'''     )

          __UpperCAmelCase      :					List[str]    				=     prepare_img()
          __UpperCAmelCase      :					Tuple    				=     image_processor(images=__lowercase				,					return_tensors='''tf'''     )

          # forward pass
          __UpperCAmelCase      :					List[Any]    				=     model(inputs.pixel_values				,					training=__lowercase     )
          __UpperCAmelCase      :					Optional[int]    				=     outputs.logits

          # verify the logits
          __UpperCAmelCase      :					Union[str, Any]    				=     tf.TensorShape((1, 21, 32, 32)     )
          self.assertEqual(logits.shape				,					__lowercase     )

          __UpperCAmelCase      :					Optional[int]    				=     tf.constant(
              [
                  [[6.9_713, 6.9_786, 7.2_422], [7.2_893, 7.2_825, 7.4_446], [7.6_580, 7.8_797, 7.9_420]],
                  [[-10.6_869, -10.3_250, -10.3_471], [-10.4_228, -9.9_868, -9.7_132], [-11.0_405, -11.0_221, -10.7_318]],
                  [[-3.3_089, -2.8_539, -2.6_740], [-3.2_706, -2.5_621, -2.5_108], [-3.2_534, -2.6_615, -2.6_651]],
              ]     )

          tf.debugging.assert_near(logits[0, :3, :3, :3]				,					__lowercase				,					rtol=1E-4				,					atol=1E-4     )






from typing import TYPE_CHECKING

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


UpperCamelCase__ :			Any       	=			{
    """configuration_splinter""": ["""SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SplinterConfig"""],
    """tokenization_splinter""": ["""SplinterTokenizer"""],
}

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCamelCase__ :			Any       	=			["""SplinterTokenizerFast"""]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCamelCase__ :			Union[str, Any]       	=			[
				    """SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """SplinterForQuestionAnswering""",
				    """SplinterForPreTraining""",
				    """SplinterLayer""",
				    """SplinterModel""",
				    """SplinterPreTrainedModel""",
				]


if TYPE_CHECKING:
				from .configuration_splinter import SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP, SplinterConfig
				from .tokenization_splinter import SplinterTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_splinter_fast import SplinterTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_splinter import (
								    SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SplinterForPreTraining,
								    SplinterForQuestionAnswering,
								    SplinterLayer,
								    SplinterModel,
								    SplinterPreTrainedModel,
								)


else:
				import sys

				UpperCamelCase__ :			List[str]       	=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


