



import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
      import torch
      from torch import nn

      from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
      from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor



class        __snake_case		:




       def __init__( self  : str       ,       A_  : List[str]       ,       A_  : List[Any]=1_3       ,       A_  : Union[str, Any]=3_2       ,       A_  : Union[str, Any]=2       ,       A_  : Optional[Any]=3       ,       A_  : List[str]=1_6       ,       A_  : Dict=[1, 2, 1]       ,       A_  : Optional[int]=[2, 2, 4]       ,       A_  : Dict=2       ,       A_  : int=2.0       ,       A_  : str=True       ,       A_  : str=0.0       ,       A_  : Any=0.0       ,       A_  : List[str]=0.1       ,       A_  : Dict="gelu"       ,       A_  : Optional[int]=False       ,       A_  : Union[str, Any]=True       ,       A_  : List[Any]=0.02       ,       A_  : List[Any]=1e-5       ,       A_  : Optional[int]=True       ,       A_  : Any=None       ,       A_  : Tuple=True       ,       A_  : Tuple=1_0       ,       A_  : Optional[int]=8       ,       A_  : Union[str, Any]=["stage1", "stage2"]       ,       A_  : List[Any]=[1, 2]       ,       ):
         lowerCAmelCase_    :  Optional[Any]             =				parent
         lowerCAmelCase_    :  Union[str, Any]             =				batch_size
         lowerCAmelCase_    :  List[Any]             =				image_size
         lowerCAmelCase_    :  List[str]             =				patch_size
         lowerCAmelCase_    :  str             =				num_channels
         lowerCAmelCase_    :  Optional[Any]             =				embed_dim
         lowerCAmelCase_    :  Dict             =				depths
         lowerCAmelCase_    :  Tuple             =				num_heads
         lowerCAmelCase_    :  Dict             =				window_size
         lowerCAmelCase_    :  int             =				mlp_ratio
         lowerCAmelCase_    :  Union[str, Any]             =				qkv_bias
         lowerCAmelCase_    :  Any             =				hidden_dropout_prob
         lowerCAmelCase_    :  Any             =				attention_probs_dropout_prob
         lowerCAmelCase_    :  Optional[Any]             =				drop_path_rate
         lowerCAmelCase_    :  str             =				hidden_act
         lowerCAmelCase_    :  List[Any]             =				use_absolute_embeddings
         lowerCAmelCase_    :  List[Any]             =				patch_norm
         lowerCAmelCase_    :  List[Any]             =				layer_norm_eps
         lowerCAmelCase_    :  Dict             =				initializer_range
         lowerCAmelCase_    :  str             =				is_training
         lowerCAmelCase_    :  List[str]             =				scope
         lowerCAmelCase_    :  Optional[Any]             =				use_labels
         lowerCAmelCase_    :  Tuple             =				type_sequence_label_size
         lowerCAmelCase_    :  int             =				encoder_stride
         lowerCAmelCase_    :  int             =				out_features
         lowerCAmelCase_    :  Any             =				out_indices




       def      UpperCAmelCase__    ( self  : List[Any]):
         lowerCAmelCase_    :  Any             =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

         lowerCAmelCase_    :  Optional[int]             =				None
         if self.use_labels:
           lowerCAmelCase_    :  Tuple             =				ids_tensor([self.batch_size]       ,       self.type_sequence_label_size)

         lowerCAmelCase_    :  List[str]             =				self.get_config()

         return config, pixel_values, labels




       def      UpperCAmelCase__    ( self  : Tuple):
         return SwinConfig(
             image_size=self.image_size       ,       patch_size=self.patch_size       ,       num_channels=self.num_channels       ,       embed_dim=self.embed_dim       ,       depths=self.depths       ,       num_heads=self.num_heads       ,       window_size=self.window_size       ,       mlp_ratio=self.mlp_ratio       ,       qkv_bias=self.qkv_bias       ,       hidden_dropout_prob=self.hidden_dropout_prob       ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,       drop_path_rate=self.drop_path_rate       ,       hidden_act=self.hidden_act       ,       use_absolute_embeddings=self.use_absolute_embeddings       ,       path_norm=self.patch_norm       ,       layer_norm_eps=self.layer_norm_eps       ,       initializer_range=self.initializer_range       ,       encoder_stride=self.encoder_stride       ,       out_features=self.out_features       ,       out_indices=self.out_indices       ,       )




       def      UpperCAmelCase__    ( self  : Optional[Any]       ,       A_  : str       ,       A_  : Tuple       ,       A_  : Optional[int]):
         lowerCAmelCase_    :  Any             =				SwinModel(config=A_)
         model.to(A_)
         model.eval()
         lowerCAmelCase_    :  Any             =				model(A_)

         lowerCAmelCase_    :  Dict             =				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
         lowerCAmelCase_    :  int             =				int(config.embed_dim * 2 ** (len(config.depths) - 1))

         self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, expected_seq_len, expected_dim))




       def      UpperCAmelCase__    ( self  : Union[str, Any]       ,       A_  : Tuple       ,       A_  : Union[str, Any]       ,       A_  : Dict):
         lowerCAmelCase_    :  List[Any]             =				SwinBackbone(config=A_)
         model.to(A_)
         model.eval()
         lowerCAmelCase_    :  int             =				model(A_)

         # verify hidden states
         self.parent.assertEqual(len(result.feature_maps)       ,       len(config.out_features))
         self.parent.assertListEqual(list(result.feature_maps[0].shape)       ,       [self.batch_size, model.channels[0], 1_6, 1_6])

         # verify channels
         self.parent.assertEqual(len(model.channels)       ,       len(config.out_features))

         # verify backbone works with out_features=None
         lowerCAmelCase_    :  Union[str, Any]             =				None
         lowerCAmelCase_    :  int             =				SwinBackbone(config=A_)
         model.to(A_)
         model.eval()
         lowerCAmelCase_    :  Tuple             =				model(A_)

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps)       ,       1)
         self.parent.assertListEqual(list(result.feature_maps[0].shape)       ,       [self.batch_size, model.channels[-1], 4, 4])

         # verify channels
         self.parent.assertEqual(len(model.channels)       ,       1)




       def      UpperCAmelCase__    ( self  : List[Any]       ,       A_  : Tuple       ,       A_  : List[str]       ,       A_  : List[str]):
         lowerCAmelCase_    :  Optional[Any]             =				SwinForMaskedImageModeling(config=A_)
         model.to(A_)
         model.eval()
         lowerCAmelCase_    :  int             =				model(A_)
         self.parent.assertEqual(
             result.logits.shape       ,       (self.batch_size, self.num_channels, self.image_size, self.image_size))

         # test greyscale images
         lowerCAmelCase_    :  Union[str, Any]             =				1
         lowerCAmelCase_    :  Tuple             =				SwinForMaskedImageModeling(A_)
         model.to(A_)
         model.eval()

         lowerCAmelCase_    :  List[str]             =				floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
         lowerCAmelCase_    :  Union[str, Any]             =				model(A_)
         self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, 1, self.image_size, self.image_size))




       def      UpperCAmelCase__    ( self  : List[str]       ,       A_  : Any       ,       A_  : Union[str, Any]       ,       A_  : Optional[Any]):
         lowerCAmelCase_    :  Dict             =				self.type_sequence_label_size
         lowerCAmelCase_    :  Tuple             =				SwinForImageClassification(A_)
         model.to(A_)
         model.eval()
         lowerCAmelCase_    :  List[str]             =				model(A_       ,       labels=A_)
         self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size))

         # test greyscale images
         lowerCAmelCase_    :  Any             =				1
         lowerCAmelCase_    :  Tuple             =				SwinForImageClassification(A_)
         model.to(A_)
         model.eval()

         lowerCAmelCase_    :  Union[str, Any]             =				floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
         lowerCAmelCase_    :  Tuple             =				model(A_)
         self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size))







       def      UpperCAmelCase__    ( self  : str):
         lowerCAmelCase_    :  Optional[int]             =				self.prepare_config_and_inputs()
         (
             lowerCAmelCase_						
         )    :  str             =				config_and_inputs
         lowerCAmelCase_    :  Optional[Any]             =				{'''pixel_values''': pixel_values}
         return config, inputs_dict





@require_torch
class        __snake_case		(  UpperCamelCase_		,UpperCamelCase_		,unittest.TestCase		):
       _a       =				(
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       _a       =				(
           {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       _a       =				True

       _a       =				False
       _a       =				False
       _a       =				False




       def      UpperCAmelCase__    ( self  : List[Any]):
         lowerCAmelCase_    :  Dict             =				SwinModelTester(self)
         lowerCAmelCase_    :  int             =				ConfigTester(self       ,       config_class=A_       ,       embed_dim=3_7)




       def      UpperCAmelCase__    ( self  : str):
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()




       def      UpperCAmelCase__    ( self  : Union[str, Any]):
         return




       def      UpperCAmelCase__    ( self  : Optional[int]):
         lowerCAmelCase_    :  Union[str, Any]             =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A_)




       @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.''')
       def      UpperCAmelCase__    ( self  : Dict):
         pass




       def      UpperCAmelCase__    ( self  : int):
         super().test_training_gradient_checkpointing()




       def      UpperCAmelCase__    ( self  : int):
         lowerCAmelCase_    :  Tuple             =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*A_)




       def      UpperCAmelCase__    ( self  : Any):
         lowerCAmelCase_    :  List[Any]             =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*A_)




       def      UpperCAmelCase__    ( self  : int):
         lowerCAmelCase_    :  int             =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*A_)




       @unittest.skip(reason='''Swin does not use inputs_embeds''')
       def      UpperCAmelCase__    ( self  : int):
         pass




       @unittest.skip(reason='''Swin Transformer does not use feedforward chunking''')
       def      UpperCAmelCase__    ( self  : Any):
         pass




       def      UpperCAmelCase__    ( self  : Optional[int]):
         lowerCAmelCase_    :  Dict             =				self.model_tester.prepare_config_and_inputs_for_common()

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




       def      UpperCAmelCase__    ( self  : Tuple):
         lowerCAmelCase_    :  Optional[Any]             =				self.model_tester.prepare_config_and_inputs_for_common()

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

           lowerCAmelCase_    :  Union[str, Any]             =				['''pixel_values''']
           self.assertListEqual(arg_names[:1]       ,       A_)




       def      UpperCAmelCase__    ( self  : Optional[int]):
         lowerCAmelCase_    :  Dict             =				self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase_    :  List[Any]             =				True

         for model_class in self.all_model_classes:
           lowerCAmelCase_    :  Any             =				True
           lowerCAmelCase_    :  Dict             =				False
           lowerCAmelCase_    :  Union[str, Any]             =				True
           lowerCAmelCase_    :  Tuple             =				model_class(A_)
           model.to(A_)
           model.eval()
           with torch.no_grad():
             lowerCAmelCase_    :  List[str]             =				model(**self._prepare_for_class(A_       ,       A_))
           lowerCAmelCase_    :  int             =				outputs.attentions
           lowerCAmelCase_    :  List[Any]             =				len(self.model_tester.depths)
           self.assertEqual(len(A_)       ,       A_)

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           lowerCAmelCase_    :  Tuple             =				True
           lowerCAmelCase_    :  List[Any]             =				config.window_size**2
           lowerCAmelCase_    :  Optional[Any]             =				model_class(A_)
           model.to(A_)
           model.eval()
           with torch.no_grad():
             lowerCAmelCase_    :  List[str]             =				model(**self._prepare_for_class(A_       ,       A_))
           lowerCAmelCase_    :  Tuple             =				outputs.attentions
           self.assertEqual(len(A_)       ,       A_)

           self.assertListEqual(
               list(attentions[0].shape[-3:])       ,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,       )
           lowerCAmelCase_    :  Tuple             =				len(A_)

           # Check attention is always last and order is fine
           lowerCAmelCase_    :  Any             =				True
           lowerCAmelCase_    :  Any             =				True
           lowerCAmelCase_    :  Tuple             =				model_class(A_)
           model.to(A_)
           model.eval()
           with torch.no_grad():
             lowerCAmelCase_    :  Dict             =				model(**self._prepare_for_class(A_       ,       A_))

           # also another +1 for reshaped_hidden_states
           lowerCAmelCase_    :  Optional[int]             =				1 if model_class.__name__ == '''SwinBackbone''' else 2
           self.assertEqual(out_len + added_hidden_states       ,       len(A_))

           lowerCAmelCase_    :  Union[str, Any]             =				outputs.attentions

           self.assertEqual(len(A_)       ,       A_)

           self.assertListEqual(
               list(self_attentions[0].shape[-3:])       ,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,       )




       def      UpperCAmelCase__    ( self  : List[Any]       ,       A_  : str       ,       A_  : Union[str, Any]       ,       A_  : Optional[Any]       ,       A_  : str):
         lowerCAmelCase_    :  int             =				model_class(A_)
         model.to(A_)
         model.eval()

         with torch.no_grad():
           lowerCAmelCase_    :  List[Any]             =				model(**self._prepare_for_class(A_       ,       A_))

         lowerCAmelCase_    :  Union[str, Any]             =				outputs.hidden_states

         lowerCAmelCase_    :  List[Any]             =				getattr(
             self.model_tester       ,       '''expected_num_hidden_layers'''       ,       len(self.model_tester.depths) + 1)
         self.assertEqual(len(A_)       ,       A_)

         # Swin has a different seq_length
         lowerCAmelCase_    :  Tuple             =				(
             config.patch_size
             if isinstance(config.patch_size       ,       collections.abc.Iterable)
             else (config.patch_size, config.patch_size)
         )

         lowerCAmelCase_    :  Tuple             =				(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:])       ,       [num_patches, self.model_tester.embed_dim]       ,       )

         if not model_class.__name__ == "SwinBackbone":
           lowerCAmelCase_    :  Optional[Any]             =				outputs.reshaped_hidden_states
           self.assertEqual(len(A_)       ,       A_)

           lowerCAmelCase_    :  Any             =				reshaped_hidden_states[0].shape
           lowerCAmelCase_    :  List[str]             =				(
               reshaped_hidden_states[0].view(A_       ,       A_       ,       height * width).permute(0       ,       2       ,       1)
           )
           self.assertListEqual(
               list(reshaped_hidden_states.shape[-2:])       ,       [num_patches, self.model_tester.embed_dim]       ,       )




       def      UpperCAmelCase__    ( self  : Any):
         lowerCAmelCase_    :  Any             =				self.model_tester.prepare_config_and_inputs_for_common()

         lowerCAmelCase_    :  Any             =				(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size       ,       collections.abc.Iterable)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

         for model_class in self.all_model_classes:
           lowerCAmelCase_    :  Union[str, Any]             =				True
           self.check_hidden_states_output(A_       ,       A_       ,       A_       ,       A_)

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

           self.check_hidden_states_output(A_       ,       A_       ,       A_       ,       A_)




       def      UpperCAmelCase__    ( self  : int):
         lowerCAmelCase_    :  Dict             =				self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase_    :  Optional[int]             =				3

         lowerCAmelCase_    :  List[str]             =				(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size       ,       collections.abc.Iterable)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
         lowerCAmelCase_    :  Union[str, Any]             =				(
             config.patch_size
             if isinstance(config.patch_size       ,       collections.abc.Iterable)
             else (config.patch_size, config.patch_size)
         )

         lowerCAmelCase_    :  List[str]             =				image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         lowerCAmelCase_    :  List[Any]             =				image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
           lowerCAmelCase_    :  Optional[Any]             =				True
           self.check_hidden_states_output(A_       ,       A_       ,       A_       ,       (padded_height, padded_width))

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           lowerCAmelCase_    :  Dict             =				True
           self.check_hidden_states_output(A_       ,       A_       ,       A_       ,       (padded_height, padded_width))




       @slow
       def      UpperCAmelCase__    ( self  : Dict):
         for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowerCAmelCase_    :  Union[str, Any]             =				SwinModel.from_pretrained(A_)
           self.assertIsNotNone(A_)







       def      UpperCAmelCase__    ( self  : Optional[Any]):
         lowerCAmelCase_    :  int             =				self.model_tester.prepare_config_and_inputs_for_common()

         lowerCAmelCase_    :  Dict             =				_config_zero_init(A_)
         for model_class in self.all_model_classes:
           lowerCAmelCase_    :  Dict             =				model_class(config=A_)
           for name, param in model.named_parameters():
             if "embeddings" not in name and param.requires_grad:
               self.assertIn(
                   ((param.data.mean() * 1e9).round() / 1e9).item()       ,       [0.0, 1.0]       ,       msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""       ,       )





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




       @cached_property
       def      UpperCAmelCase__    ( self  : List[str]):
         return (
             AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''')
             if is_vision_available()
             else None
         )







       @slow
       def      UpperCAmelCase__    ( self  : str):
         lowerCAmelCase_    :  Tuple             =				SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''').to(A_)
         lowerCAmelCase_    :  Optional[Any]             =				self.default_image_processor

         lowerCAmelCase_    :  Union[str, Any]             =				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
         lowerCAmelCase_    :  Optional[int]             =				image_processor(images=A_       ,       return_tensors='''pt''').to(A_)

         # forward pass
         with torch.no_grad():
           lowerCAmelCase_    :  List[Any]             =				model(**A_)

         # verify the logits
         lowerCAmelCase_    :  List[Any]             =				torch.Size((1, 1_0_0_0))
         self.assertEqual(outputs.logits.shape       ,       A_)
         lowerCAmelCase_    :  Tuple             =				torch.tensor([-0.0948, -0.6454, -0.0921]).to(A_)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,       A_       ,       atol=1e-4))





@require_torch
class        __snake_case		(  unittest.TestCase		,UpperCamelCase_		):
       _a       =				(SwinBackbone,) if is_torch_available() else ()
       _a       =				SwinConfig




       def      UpperCAmelCase__    ( self  : str):
         lowerCAmelCase_    :  Dict             =				SwinModelTester(self)










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


A__						:						List[str]          =      {
    '''configuration_segformer''': ['''SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SegformerConfig''', '''SegformerOnnxConfig''']
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A__						:						int          =      ['''SegformerFeatureExtractor''']
						A__						:						Dict          =      ['''SegformerImageProcessor''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A__						:						Any          =      [
						    '''SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''SegformerDecodeHead''',
						    '''SegformerForImageClassification''',
						    '''SegformerForSemanticSegmentation''',
						    '''SegformerLayer''',
						    '''SegformerModel''',
						    '''SegformerPreTrainedModel''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A__						:						List[Any]          =      [
						    '''TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFSegformerDecodeHead''',
						    '''TFSegformerForImageClassification''',
						    '''TFSegformerForSemanticSegmentation''',
						    '''TFSegformerModel''',
						    '''TFSegformerPreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_segformer import SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SegformerConfig, SegformerOnnxConfig

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_segformer import SegformerFeatureExtractor
												from .image_processing_segformer import SegformerImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_segformer import (
												    SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    SegformerDecodeHead,
												    SegformerForImageClassification,
												    SegformerForSemanticSegmentation,
												    SegformerLayer,
												    SegformerModel,
												    SegformerPreTrainedModel,
												)
						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_segformer import (
												    TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFSegformerDecodeHead,
												    TFSegformerForImageClassification,
												    TFSegformerForSemanticSegmentation,
												    TFSegformerModel,
												    TFSegformerPreTrainedModel,
												)

else:
						import sys

						A__						:						Dict          =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





