



'''simple docstring'''





from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

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 tensorflow as tf

       from transformers.models.swin.modeling_tf_swin import (
           TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFSwinForImageClassification,
           TFSwinForMaskedImageModeling,
           TFSwinModel,
       )


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor






class __A      :



 '''simple docstring'''







 def __init__(self			,       A			,       A=13			,       A=32			,       A=2			,       A=3			,       A=16			,       A=[1, 2, 1]			,       A=[2, 2, 4]			,       A=2			,       A=2.0			,       A=True			,       A=0.0			,       A=0.0			,       A=0.1			,       A="gelu"			,       A=False			,       A=True			,       A=0.02			,       A=1E-5			,       A=True			,       A=None			,       A=True			,       A=10			,       A=8			,       )   ->					Any:


      """simple docstring"""



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



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


      """simple docstring"""



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

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

      _a     =  self.get_config()

      return config, pixel_values, labels



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


      """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			,       )



 def  a__  (self			,       A			,       A			,       A	)   ->					int:


      """simple docstring"""



      _a     =  TFSwinModel(config=A	)
      _a     =  model(A	)

      _a     =  ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
      _a     =  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  a__  (self			,       A			,       A			,       A	)   ->					Optional[Any]:


      """simple docstring"""



      _a     =  TFSwinForMaskedImageModeling(config=A	)
      _a     =  model(A	)
      self.parent.assertEqual(
          result.logits.shape			,       (self.batch_size, self.num_channels, self.image_size, self.image_size)	)

      # test greyscale images
      _a     =  1
      _a     =  TFSwinForMaskedImageModeling(A	)

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



 def  a__  (self			,       A			,       A			,       A	)   ->					Optional[int]:


      """simple docstring"""



      _a     =  self.type_sequence_label_size
      _a     =  TFSwinForImageClassification(A	)
      _a     =  model(A			,       labels=A	)
      self.parent.assertEqual(result.logits.shape			,       (self.batch_size, self.type_sequence_label_size)	)

      # test greyscale images
      _a     =  1
      _a     =  TFSwinForImageClassification(A	)
      _a     =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
      _a     =  model(A	)
      self.parent.assertEqual(result.logits.shape			,       (self.batch_size, self.type_sequence_label_size)	)



 def  a__  (self	)   ->					Dict:


      """simple docstring"""



      _a     =  self.prepare_config_and_inputs()
      _a  ,   _a  ,   _a     =  config_and_inputs
      _a     =  {'''pixel_values''': pixel_values}
      return config, inputs_dict






@require_tf
class __A      (  A__       ,       A__       ,       unittest.TestCase						):



 '''simple docstring'''







 __lowerCamelCase   :	Tuple										=	(
     (
         TFSwinModel,
         TFSwinForImageClassification,
         TFSwinForMaskedImageModeling,
     )
     if is_tf_available()
     else ()
 )
 __lowerCamelCase   :	str										=	(
     {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
     if is_tf_available()
     else {}
 )

 __lowerCamelCase   :	str										=	False
 __lowerCamelCase   :	List[str]										=	False
 __lowerCamelCase   :	Any										=	False
 __lowerCamelCase   :	Union[str, Any]										=	False



 def  a__  (self	)   ->					Any:


      """simple docstring"""



      _a     =  TFSwinModelTester(self	)
      _a     =  ConfigTester(self			,       config_class=A			,       embed_dim=37	)



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


      """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  a__  (self	)   ->					List[Any]:


      """simple docstring"""



      return



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


      """simple docstring"""



      _a     =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A	)



 def  a__  (self	)   ->					int:


      """simple docstring"""



      _a     =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*A	)



 def  a__  (self	)   ->					Any:


      """simple docstring"""



      _a     =  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  a__  (self	)   ->					Optional[int]:


      """simple docstring"""



      pass



 def  a__  (self	)   ->					str:


      """simple docstring"""



      _a  ,   _a     =  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _a     =  model_class(A	)
           self.assertIsInstance(model.get_input_embeddings()			,       tf.keras.layers.Layer	)
           _a     =  model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(A			,       tf.keras.layers.Dense	)	)



 def  a__  (self	)   ->					int:


      """simple docstring"""



      _a  ,   _a     =  self.model_tester.prepare_config_and_inputs_for_common()

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

           _a     =  ['''pixel_values''']
           self.assertListEqual(arg_names[:1]			,       A	)



 def  a__  (self	)   ->					int:


      """simple docstring"""



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

      for model_class in self.all_model_classes:
           _a     =  True
           _a     =  False
           _a     =  True
           _a     =  model_class(A	)
           _a     =  model(**self._prepare_for_class(A			,       A	)	)
           _a     =  outputs.attentions
           _a     =  len(self.model_tester.depths	)
           self.assertEqual(len(A	)			,       A	)

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           _a     =  True
           _a     =  config.window_size**2
           _a     =  model_class(A	)
           _a     =  model(**self._prepare_for_class(A			,       A	)	)
           _a     =  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]			,       )
           _a     =  len(A	)

           # Check attention is always last and order is fine
           _a     =  True
           _a     =  True
           _a     =  model_class(A	)
           _a     =  model(**self._prepare_for_class(A			,       A	)	)

           if hasattr(self.model_tester			,       '''num_hidden_states_types'''	):
                _a     =  self.model_tester.num_hidden_states_types
           else:
                # also another +1 for reshaped_hidden_states
                _a     =  2
           self.assertEqual(out_len + added_hidden_states			,       len(A	)	)

           _a     =  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  a__  (self			,       A			,       A			,       A			,       A	)   ->					Optional[Any]:


      """simple docstring"""



      _a     =  model_class(A	)
      _a     =  model(**self._prepare_for_class(A			,       A	)	)
      _a     =  outputs.hidden_states

      _a     =  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
      _a     =  to_atuple(config.patch_size	)

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

      _a     =  outputs.reshaped_hidden_states
      self.assertEqual(len(A	)			,       A	)

      _a  ,   _a  ,   _a  ,   _a     =  reshaped_hidden_states[0].shape

      _a     =  tf.reshape(reshaped_hidden_states[0]			,       (batch_size, num_channels, height * width)	)
      _a     =  tf.transpose(A			,       (0, 2, 1)	)

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



 def  a__  (self	)   ->					Tuple:


      """simple docstring"""



      _a  ,   _a     =  self.model_tester.prepare_config_and_inputs_for_common()

      _a     =  to_atuple(self.model_tester.image_size	)

      for model_class in self.all_model_classes:
           _a     =  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"]
           _a     =  True

           self.check_hidden_states_output(A			,       A			,       A			,       A	)



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


      """simple docstring"""



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

      _a     =  to_atuple(self.model_tester.image_size	)
      _a     =  to_atuple(config.patch_size	)

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

      for model_class in self.all_model_classes:
           _a     =  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"]
           _a     =  True
           self.check_hidden_states_output(A			,       A			,       A			,       (padded_height, padded_width)	)



 @slow
 def  a__  (self	)   ->					Tuple:


      """simple docstring"""



      for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a     =  TFSwinModel.from_pretrained(A	)
           self.assertIsNotNone(A	)






@require_vision
@require_tf
class __A      (  unittest.TestCase						):



 '''simple docstring'''







 @cached_property
 def  a__  (self	)   ->					Optional[Any]:


      """simple docstring"""



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



 @slow
 def  a__  (self	)   ->					int:


      """simple docstring"""



      _a     =  TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''	)
      _a     =  self.default_image_processor

      _a     =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
      _a     =  image_processor(images=A			,       return_tensors='''tf'''	)

      # forward pass
      _a     =  model(A	)

      # verify the logits
      _a     =  tf.TensorShape((1, 1_000)	)
      self.assertEqual(outputs.logits.shape			,       A	)
      _a     =  tf.constant([-0.0948, -0.6454, -0.0921]	)
      self.assertTrue(np.allclose(outputs.logits[0, :3]			,       A			,       atol=1E-4	)	)








'''simple docstring'''





from typing import TYPE_CHECKING

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


lowercase_			=  {
    "configuration_segformer": ["SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "SegformerConfig", "SegformerOnnxConfig"]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase_			=  ["SegformerFeatureExtractor"]
  lowercase_			=  ["SegformerImageProcessor"]

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

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase_			=  [
      "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

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



