





"""simple docstring"""


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   lowercase_					:

       def __init__(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE=13 ,       __SCREAMING_SNAKE_CASE=32 ,       __SCREAMING_SNAKE_CASE=2 ,       __SCREAMING_SNAKE_CASE=3 ,       __SCREAMING_SNAKE_CASE=16 ,       __SCREAMING_SNAKE_CASE=[1, 2, 1] ,       __SCREAMING_SNAKE_CASE=[2, 2, 4] ,       __SCREAMING_SNAKE_CASE=2 ,       __SCREAMING_SNAKE_CASE=2.0 ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=0.0 ,       __SCREAMING_SNAKE_CASE=0.0 ,       __SCREAMING_SNAKE_CASE=0.1 ,       __SCREAMING_SNAKE_CASE="gelu" ,       __SCREAMING_SNAKE_CASE=False ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=0.02 ,       __SCREAMING_SNAKE_CASE=1e-5 ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=None ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=10 ,       __SCREAMING_SNAKE_CASE=8 ,       __SCREAMING_SNAKE_CASE=["stage1", "stage2"] ,       __SCREAMING_SNAKE_CASE=[1, 2] ,       ):






        '''simple docstring'''

        snake_case__     				=					parent
        snake_case__     				=					batch_size
        snake_case__     				=					image_size
        snake_case__     				=					patch_size
        snake_case__     				=					num_channels
        snake_case__     				=					embed_dim
        snake_case__     				=					depths
        snake_case__     				=					num_heads
        snake_case__     				=					window_size
        snake_case__     				=					mlp_ratio
        snake_case__     				=					qkv_bias
        snake_case__     				=					hidden_dropout_prob
        snake_case__     				=					attention_probs_dropout_prob
        snake_case__     				=					drop_path_rate
        snake_case__     				=					hidden_act
        snake_case__     				=					use_absolute_embeddings
        snake_case__     				=					patch_norm
        snake_case__     				=					layer_norm_eps
        snake_case__     				=					initializer_range
        snake_case__     				=					is_training
        snake_case__     				=					scope
        snake_case__     				=					use_labels
        snake_case__     				=					type_sequence_label_size
        snake_case__     				=					encoder_stride
        snake_case__     				=					out_features
        snake_case__     				=					out_indices

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

        snake_case__     				=					None
        if self.use_labels:
         snake_case__     				=					ids_tensor([self.batch_size] ,       self.type_sequence_label_size  )

        snake_case__     				=					self.get_config()

        return config, pixel_values, labels

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        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 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					SwinModel(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )

        snake_case__     				=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
        snake_case__     				=					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 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					SwinBackbone(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )

        # 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], 16, 16]  )

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

        # verify backbone works with out_features=None
        snake_case__     				=					None
        snake_case__     				=					SwinBackbone(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )

        # 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 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					SwinForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )
        self.parent.assertEqual(
            result.logits.shape ,       (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

        # test greyscale images
        snake_case__     				=					1
        snake_case__     				=					SwinForMaskedImageModeling(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()

        snake_case__     				=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )
        self.parent.assertEqual(result.logits.shape ,       (self.batch_size, 1, self.image_size, self.image_size)  )

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					self.type_sequence_label_size
        snake_case__     				=					SwinForImageClassification(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					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
        snake_case__     				=					1
        snake_case__     				=					SwinForImageClassification(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()

        snake_case__     				=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )
        self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size)  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.prepare_config_and_inputs()
        (
            (
            snake_case__
        )				, (
            snake_case__
        )				, (
            snake_case__
        )				, 
        )     				=					config_and_inputs
        snake_case__     				=					{"pixel_values": pixel_values}
        return config, inputs_dict



@require_torch
class   lowercase_					(  __lowerCAmelCase					,__lowerCAmelCase					,unittest.TestCase				):
       snake_case__					:				List[str]									=  (
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       snake_case__					:				Optional[Any]									=  (
           {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       snake_case__					:				Union[str, Any]									=  True

       snake_case__					:				Any									=  False
       snake_case__					:				Union[str, Any]									=  False
       snake_case__					:				Union[str, Any]									=  False

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					SwinModelTester(self  )
        snake_case__     				=					ConfigTester(self ,       config_class=__SCREAMING_SNAKE_CASE ,       embed_dim=37  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        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 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        return

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE  )

       @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."  )
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        super().test_training_gradient_checkpointing()

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE  )

       @unittest.skip(reason="Swin does not use inputs_embeds"  )
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       @unittest.skip(reason="Swin Transformer does not use feedforward chunking"  )
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case__     				=					model_class(__SCREAMING_SNAKE_CASE  )
         self.assertIsInstance(model.get_input_embeddings() ,       (nn.Module)  )
         snake_case__     				=					model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE ,       nn.Linear  )  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()

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

         snake_case__     				=					["pixel_values"]
         self.assertListEqual(arg_names[:1] ,       __SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()
        snake_case__     				=					True

        for model_class in self.all_model_classes:
         snake_case__     				=					True
         snake_case__     				=					False
         snake_case__     				=					True
         snake_case__     				=					model_class(__SCREAMING_SNAKE_CASE  )
         model.to(__SCREAMING_SNAKE_CASE  )
         model.eval()
         with torch.no_grad():
          snake_case__     				=					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )  )
         snake_case__     				=					outputs.attentions
         snake_case__     				=					len(self.model_tester.depths  )
         self.assertEqual(len(__SCREAMING_SNAKE_CASE  ) ,       __SCREAMING_SNAKE_CASE  )

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

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

         # Check attention is always last and order is fine
         snake_case__     				=					True
         snake_case__     				=					True
         snake_case__     				=					model_class(__SCREAMING_SNAKE_CASE  )
         model.to(__SCREAMING_SNAKE_CASE  )
         model.eval()
         with torch.no_grad():
          snake_case__     				=					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )  )

         # also another +1 for reshaped_hidden_states
         snake_case__     				=					1 if model_class.__name__ == "SwinBackbone" else 2
         self.assertEqual(out_len + added_hidden_states ,       len(__SCREAMING_SNAKE_CASE  )  )

         snake_case__     				=					outputs.attentions

         self.assertEqual(len(__SCREAMING_SNAKE_CASE  ) ,       __SCREAMING_SNAKE_CASE  )

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

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					model_class(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()

        with torch.no_grad():
         snake_case__     				=					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )  )

        snake_case__     				=					outputs.hidden_states

        snake_case__     				=					getattr(
            self.model_tester ,       "expected_num_hidden_layers" ,       len(self.model_tester.depths  ) + 1  )
        self.assertEqual(len(__SCREAMING_SNAKE_CASE  ) ,       __SCREAMING_SNAKE_CASE  )

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

        snake_case__     				=					(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":
         snake_case__     				=					outputs.reshaped_hidden_states
         self.assertEqual(len(__SCREAMING_SNAKE_CASE  ) ,       __SCREAMING_SNAKE_CASE  )

         snake_case__				, snake_case__				, snake_case__				, snake_case__     				=					reshaped_hidden_states[0].shape
         snake_case__     				=					(
             reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       height * width  ).permute(0 ,       2 ,       1  )
         )
         self.assertListEqual(
             list(reshaped_hidden_states.shape[-2:]  ) ,       [num_patches, self.model_tester.embed_dim] ,       )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()

        snake_case__     				=					(
            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:
         snake_case__     				=					True
         self.check_hidden_states_output(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         snake_case__     				=					True

         self.check_hidden_states_output(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()
        snake_case__     				=					3

        snake_case__     				=					(
            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)
        )
        snake_case__     				=					(
            config.patch_size
            if isinstance(config.patch_size ,       collections.abc.Iterable  )
            else (config.patch_size, config.patch_size)
        )

        snake_case__     				=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        snake_case__     				=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

        for model_class in self.all_model_classes:
         snake_case__     				=					True
         self.check_hidden_states_output(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       (padded_height, padded_width)  )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         snake_case__     				=					True
         self.check_hidden_states_output(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       (padded_height, padded_width)  )

       @slow
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case__     				=					SwinModel.from_pretrained(__SCREAMING_SNAKE_CASE  )
         self.assertIsNotNone(__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()

        snake_case__     				=					_config_zero_init(__SCREAMING_SNAKE_CASE  )
        for model_class in self.all_model_classes:
         snake_case__     				=					model_class(config=__SCREAMING_SNAKE_CASE  )
         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   lowercase_					(  unittest.TestCase				):

       @cached_property
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        return (
            AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"  )
            if is_vision_available()
            else None
        )

       @slow
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"  ).to(__SCREAMING_SNAKE_CASE  )
        snake_case__     				=					self.default_image_processor

        snake_case__     				=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
        snake_case__     				=					image_processor(images=__SCREAMING_SNAKE_CASE ,       return_tensors="pt"  ).to(__SCREAMING_SNAKE_CASE  )

        # forward pass
        with torch.no_grad():
         snake_case__     				=					model(**__SCREAMING_SNAKE_CASE  )

        # verify the logits
        snake_case__     				=					torch.Size((1, 1000)  )
        self.assertEqual(outputs.logits.shape ,       __SCREAMING_SNAKE_CASE  )
        snake_case__     				=					torch.tensor([-0.0948, -0.6454, -0.0921]  ).to(__SCREAMING_SNAKE_CASE  )
        self.assertTrue(torch.allclose(outputs.logits[0, :3] ,       __SCREAMING_SNAKE_CASE ,       atol=1e-4  )  )



@require_torch
class   lowercase_					(  unittest.TestCase					,__lowerCAmelCase				):
       snake_case__					:				int									=  (SwinBackbone,) if is_torch_available() else ()
       snake_case__					:				Union[str, Any]									=  SwinConfig

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					SwinModelTester(self  )








"""simple docstring"""


from typing import TYPE_CHECKING

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


a__       :  List[Any]       		=					{
    """configuration_realm""": ["""REALM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RealmConfig"""],
    """tokenization_realm""": ["""RealmTokenizer"""],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   a__       :  Union[str, Any]       		=					["""RealmTokenizerFast"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   a__       :  Dict       		=					[
       """REALM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """RealmEmbedder""",
       """RealmForOpenQA""",
       """RealmKnowledgeAugEncoder""",
       """RealmPreTrainedModel""",
       """RealmReader""",
       """RealmScorer""",
       """load_tf_weights_in_realm""",
   ]
   a__       :  Any       		=					["""RealmRetriever"""]


if TYPE_CHECKING:
   from .configuration_realm import REALM_PRETRAINED_CONFIG_ARCHIVE_MAP, RealmConfig
   from .tokenization_realm import RealmTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_realm import RealmTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_realm import (
          REALM_PRETRAINED_MODEL_ARCHIVE_LIST,
          RealmEmbedder,
          RealmForOpenQA,
          RealmKnowledgeAugEncoder,
          RealmPreTrainedModel,
          RealmReader,
          RealmScorer,
          load_tf_weights_in_realm,
      )
      from .retrieval_realm import RealmRetriever


else:
   import sys

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

