'''simple docstring'''

import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
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 MaskFormerSwinBackbone
 from transformers.models.maskformer import MaskFormerSwinModel


class     __UpperCAmelCase       :





  def __init__(	self    ,     _lowerCamelCase    ,     _lowerCamelCase=13    ,     _lowerCamelCase=32    ,     _lowerCamelCase=2    ,     _lowerCamelCase=3    ,     _lowerCamelCase=16    ,     _lowerCamelCase=[1, 2, 1]    ,     _lowerCamelCase=[2, 2, 4]    ,     _lowerCamelCase=2    ,     _lowerCamelCase=2.0    ,     _lowerCamelCase=True    ,     _lowerCamelCase=0.0    ,     _lowerCamelCase=0.0    ,     _lowerCamelCase=0.1    ,     _lowerCamelCase="gelu"    ,     _lowerCamelCase=False    ,     _lowerCamelCase=True    ,     _lowerCamelCase=0.02    ,     _lowerCamelCase=1E-5    ,     _lowerCamelCase=True    ,     _lowerCamelCase=None    ,     _lowerCamelCase=True    ,     _lowerCamelCase=10    ,     _lowerCamelCase=8    ,     _lowerCamelCase=["stage1", "stage2", "stage3"]    ,     _lowerCamelCase=[1, 2, 3]    ,     ):
     lowerCAmelCase_			=      parent
     lowerCAmelCase_			=      batch_size
     lowerCAmelCase_			=      image_size
     lowerCAmelCase_			=      patch_size
     lowerCAmelCase_			=      num_channels
     lowerCAmelCase_			=      embed_dim
     lowerCAmelCase_			=      depths
     lowerCAmelCase_			=      num_heads
     lowerCAmelCase_			=      window_size
     lowerCAmelCase_			=      mlp_ratio
     lowerCAmelCase_			=      qkv_bias
     lowerCAmelCase_			=      hidden_dropout_prob
     lowerCAmelCase_			=      attention_probs_dropout_prob
     lowerCAmelCase_			=      drop_path_rate
     lowerCAmelCase_			=      hidden_act
     lowerCAmelCase_			=      use_absolute_embeddings
     lowerCAmelCase_			=      patch_norm
     lowerCAmelCase_			=      layer_norm_eps
     lowerCAmelCase_			=      initializer_range
     lowerCAmelCase_			=      is_training
     lowerCAmelCase_			=      scope
     lowerCAmelCase_			=      use_labels
     lowerCAmelCase_			=      type_sequence_label_size
     lowerCAmelCase_			=      encoder_stride
     lowerCAmelCase_			=      out_features
     lowerCAmelCase_			=      out_indices





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

     lowerCAmelCase_			=      self.get_config()

     return config, pixel_values, labels





  def 						UpperCAmelCase_	(	self ):
     return MaskFormerSwinConfig(
         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    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase ):
     lowerCAmelCase_			=      MaskFormerSwinModel(config=snake_case__ )
     model.to(snake_case__ )
     model.eval()
     lowerCAmelCase_			=      model(snake_case__ )

     lowerCAmelCase_			=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
     lowerCAmelCase_			=      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    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase ):
     lowerCAmelCase_			=      MaskFormerSwinBackbone(config=snake_case__ )
     model.to(snake_case__ )
     model.eval()
     lowerCAmelCase_			=      model(snake_case__ )

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps )    ,     len(config.out_features ) )
     self.parent.assertListEqual(list(result.feature_maps[0].shape )    ,     [13, 16, 16, 16] )

     # verify channels
     self.parent.assertEqual(len(model.channels )    ,     len(config.out_features ) )
     self.parent.assertListEqual(model.channels    ,     [16, 32, 64] )

     # verify ValueError
     with self.parent.assertRaises(snake_case__ ):
        lowerCAmelCase_			=      ["stem"]
        lowerCAmelCase_			=      MaskFormerSwinBackbone(config=snake_case__ )







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






@require_torch
class     __UpperCAmelCase       ( __a						,       __a						,       unittest.TestCase		):
  __A :				int											= (
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  __A :				int											= {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
  __A :				Optional[int]											= False
  __A :				int											= False
  __A :				Tuple											= False
  __A :				Tuple											= False
  __A :				Union[str, Any]											= False





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      MaskFormerSwinModelTester(self )
     lowerCAmelCase_			=      ConfigTester(self    ,     config_class=snake_case__    ,     embed_dim=37 )





  @require_torch_multi_gpu
  @unittest.skip(
      reason=(
          '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
          ''' `nn.DataParallel`'''
      ) )
  def 						UpperCAmelCase_	(	self ):
     pass





  def 						UpperCAmelCase_	(	self ):
     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 ):
     return





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*snake_case__ )





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*snake_case__ )





  @unittest.skip('''Swin does not use inputs_embeds''' )
  def 						UpperCAmelCase_	(	self ):
     pass





  @unittest.skip('''Swin does not support feedforward chunking''' )
  def 						UpperCAmelCase_	(	self ):
     pass





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs_for_common()

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





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs_for_common()

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

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





  @unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions''' )
  def 						UpperCAmelCase_	(	self ):
     pass





  @unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone''' )
  def 						UpperCAmelCase_	(	self ):
     pass





  def 						UpperCAmelCase_	(	self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase ):
     lowerCAmelCase_			=      model_class(snake_case__ )
     model.to(snake_case__ )
     model.eval()

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

     lowerCAmelCase_			=      outputs.hidden_states

     lowerCAmelCase_			=      getattr(
         self.model_tester    ,     '''expected_num_hidden_layers'''    ,     len(self.model_tester.depths ) + 1 )
     self.assertEqual(len(snake_case__ )    ,     snake_case__ )

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

     lowerCAmelCase_			=      (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]    ,     )





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs_for_common()

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

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

        self.check_hidden_states_output(snake_case__    ,     snake_case__    ,     snake_case__    ,     snake_case__ )





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs_for_common()
     lowerCAmelCase_			=      3

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

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

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

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





  @unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints''' )
  def 						UpperCAmelCase_	(	self ):
     pass





  @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin''' )
  def 						UpperCAmelCase_	(	self ):
     pass





  @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin''' )
  def 						UpperCAmelCase_	(	self ):
     pass







  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs_for_common()

     def set_nan_tensor_to_zero(_lowerCamelCase ):
        lowerCAmelCase_			=      0
        return t

     def check_equivalence(_lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase={} ):
        with torch.no_grad():
           lowerCAmelCase_			=      model(**snake_case__    ,     return_dict=snake_case__    ,     **snake_case__ )
           lowerCAmelCase_			=      model(**snake_case__    ,     return_dict=snake_case__    ,     **snake_case__ ).to_tuple()

           def recursive_check(_lowerCamelCase    ,     _lowerCamelCase ):
              if isinstance(snake_case__    ,     (List, Tuple) ):
                 for tuple_iterable_value, dict_iterable_value in zip(snake_case__    ,     snake_case__ ):
                    recursive_check(snake_case__    ,     snake_case__ )
              elif isinstance(snake_case__    ,     snake_case__ ):
                 for tuple_iterable_value, dict_iterable_value in zip(
                     tuple_object.values()    ,     dict_object.values() ):
                    recursive_check(snake_case__    ,     snake_case__ )
              elif tuple_object is None:
                 return
              else:
                 self.assertTrue(
                     torch.allclose(
                         set_nan_tensor_to_zero(snake_case__ )    ,     set_nan_tensor_to_zero(snake_case__ )    ,     atol=1E-5 )    ,     msg=(
                         '''Tuple and dict output are not equal. Difference:'''
                         F''' {torch.max(torch.abs(tuple_object - dict_object ) )}. Tuple has `nan`:'''
                         F''' {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}. Dict has'''
                         F''' `nan`: {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}.'''
                     )    ,     )

           recursive_check(snake_case__    ,     snake_case__ )

     for model_class in self.all_model_classes:
        lowerCAmelCase_			=      model_class(snake_case__ )
        model.to(snake_case__ )
        model.eval()

        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__ )
        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__ )
        check_equivalence(snake_case__    ,     snake_case__    ,     snake_case__ )

        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__    ,     return_labels=snake_case__ )
        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__    ,     return_labels=snake_case__ )
        check_equivalence(snake_case__    ,     snake_case__    ,     snake_case__ )

        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__ )
        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__ )
        check_equivalence(snake_case__    ,     snake_case__    ,     snake_case__    ,     {'''output_hidden_states''': True} )

        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__    ,     return_labels=snake_case__ )
        lowerCAmelCase_			=      self._prepare_for_class(snake_case__    ,     snake_case__    ,     return_labels=snake_case__ )
        check_equivalence(snake_case__    ,     snake_case__    ,     snake_case__    ,     {'''output_hidden_states''': True} )






@require_torch
class     __UpperCAmelCase       ( unittest.TestCase						,       __a		):
  __A :				Optional[int]											= (MaskFormerSwinBackbone,) if is_torch_available() else ()
  __A :				int											= MaskFormerSwinConfig





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      MaskFormerSwinModelTester(self )







  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.model_tester.prepare_config_and_inputs_for_common()
     lowerCAmelCase_			=      inputs_dict["pixel_values"].shape[0]

     for backbone_class in self.all_model_classes:
        lowerCAmelCase_			=      backbone_class(snake_case__ )
        backbone.to(snake_case__ )
        backbone.eval()

        lowerCAmelCase_			=      backbone(**snake_case__ )

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps    ,     snake_case__ )
        self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) )
        for feature_map, n_channels in zip(outputs.feature_maps    ,     backbone.channels ):
           self.assertTrue(feature_map.shape[:2]    ,     (batch_size, n_channels) )
        self.assertIsNone(outputs.hidden_states )
        self.assertIsNone(outputs.attentions )

        # Test output_hidden_states=True
        lowerCAmelCase_			=      backbone(**snake_case__    ,     output_hidden_states=snake_case__ )
        self.assertIsNotNone(outputs.hidden_states )
        self.assertTrue(len(outputs.hidden_states )    ,     len(backbone.stage_names ) )
        # We skip the stem layer
        for hidden_states, n_channels in zip(outputs.hidden_states[1:]    ,     backbone.channels ):
           for hidden_state in hidden_states:
              # Hidden states are in the format (batch_size, (height * width), n_channels)
              lowerCAmelCase_			=      hidden_state.shape
              self.assertTrue((h_batch_size, h_n_channels)    ,     (batch_size, n_channels) )

                 # Test output_attentions=True
        if self.has_attentions:
           lowerCAmelCase_			=      backbone(**snake_case__    ,     output_attentions=snake_case__ )
           self.assertIsNotNone(outputs.attentions )







'''simple docstring'''





from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE     =       {"""configuration_deit""": ["""DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DeiTConfig""", """DeiTOnnxConfig"""]}

try:
      if not is_vision_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE     =       ["""DeiTFeatureExtractor"""]
      SCREAMING_SNAKE_CASE     =       ["""DeiTImageProcessor"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE     =       [
          """DEIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """DeiTForImageClassification""",
          """DeiTForImageClassificationWithTeacher""",
          """DeiTForMaskedImageModeling""",
          """DeiTModel""",
          """DeiTPreTrainedModel""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE     =       [
          """TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFDeiTForImageClassification""",
          """TFDeiTForImageClassificationWithTeacher""",
          """TFDeiTForMaskedImageModeling""",
          """TFDeiTModel""",
          """TFDeiTPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_deit import DeiTFeatureExtractor
            from .image_processing_deit import DeiTImageProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_deit import (
                DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                DeiTForImageClassification,
                DeiTForImageClassificationWithTeacher,
                DeiTForMaskedImageModeling,
                DeiTModel,
                DeiTPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_deit import (
                TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFDeiTForImageClassification,
                TFDeiTForImageClassificationWithTeacher,
                TFDeiTForMaskedImageModeling,
                TFDeiTModel,
                TFDeiTPreTrainedModel,
            )


else:
      import sys

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



