





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





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





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

        _UpperCAmelCase											=      self.get_config()

        return config, pixel_values, labels





     def 		UpperCamelCase(    self				):
        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 		UpperCamelCase(    self							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase				):
        _UpperCAmelCase											=      TFSwinModel(config=_UpperCamelCase				)
        _UpperCAmelCase											=      model(_UpperCamelCase				)

        _UpperCAmelCase											=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
        _UpperCAmelCase											=      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							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase				):
        _UpperCAmelCase											=      TFSwinForMaskedImageModeling(config=_UpperCamelCase				)
        _UpperCAmelCase											=      model(_UpperCamelCase				)
        self.parent.assertEqual(
            result.logits.shape							,       (self.batch_size, self.num_channels, self.image_size, self.image_size)				)

        # test greyscale images
        _UpperCAmelCase											=      1
        _UpperCAmelCase											=      TFSwinForMaskedImageModeling(_UpperCamelCase				)

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





     def 		UpperCamelCase(    self							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase				):
        _UpperCAmelCase											=      self.type_sequence_label_size
        _UpperCAmelCase											=      TFSwinForImageClassification(_UpperCamelCase				)
        _UpperCAmelCase											=      model(_UpperCamelCase							,       labels=_UpperCamelCase				)
        self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.type_sequence_label_size)				)

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





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




@require_tf
class  __UpperCamelCase						(       A__  ,   A__  ,   unittest.TestCase						):
     __A  :     Any            =      (
         (
             TFSwinModel,
             TFSwinForImageClassification,
             TFSwinForMaskedImageModeling,
         )
         if is_tf_available()
         else ()
     )
     __A  :     List[Any]            =      (
         {"""feature-extraction""": TFSwinModel, """image-classification""": TFSwinForImageClassification}
         if is_tf_available()
         else {}
     )

     __A  :     Dict            =      False
     __A  :     Optional[int]            =      False
     __A  :     Tuple            =      False
     __A  :     Optional[int]            =      False





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      TFSwinModelTester(self				)
        _UpperCAmelCase											=      ConfigTester(self							,       config_class=_UpperCamelCase							,       embed_dim=37				)





     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				):
        _UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_UpperCamelCase				)





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCamelCase				)





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase				)





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





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase					,			_UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs_for_common()

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





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase					,			_UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs_for_common()

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

           _UpperCAmelCase											=      ['''pixel_values''']
           self.assertListEqual(arg_names[:1]							,       _UpperCamelCase				)





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase					,			_UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs_for_common()
        _UpperCAmelCase											=      True

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

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           _UpperCAmelCase											=      True
           _UpperCAmelCase											=      config.window_size**2
           _UpperCAmelCase											=      model_class(_UpperCamelCase				)
           _UpperCAmelCase											=      model(**self._prepare_for_class(_UpperCamelCase							,       _UpperCamelCase				)				)
           _UpperCAmelCase											=      outputs.attentions
           self.assertEqual(len(_UpperCamelCase				)							,       _UpperCamelCase				)

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

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

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

           _UpperCAmelCase											=      outputs.attentions

           self.assertEqual(len(_UpperCamelCase				)							,       _UpperCamelCase				)

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





     def 		UpperCamelCase(    self							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase				):
        _UpperCAmelCase											=      model_class(_UpperCamelCase				)
        _UpperCAmelCase											=      model(**self._prepare_for_class(_UpperCamelCase							,       _UpperCamelCase				)				)
        _UpperCAmelCase											=      outputs.hidden_states

        _UpperCAmelCase											=      getattr(
            self.model_tester							,       '''expected_num_hidden_layers'''							,       len(self.model_tester.depths				) + 1				)
        self.assertEqual(len(_UpperCamelCase				)							,       _UpperCamelCase				)

        # Swin has a different seq_length
        _UpperCAmelCase											=      to_atuple(config.patch_size				)

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

        _UpperCAmelCase											=      outputs.reshaped_hidden_states
        self.assertEqual(len(_UpperCamelCase				)							,       _UpperCamelCase				)

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

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

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





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase					,			_UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs_for_common()

        _UpperCAmelCase											=      to_atuple(self.model_tester.image_size				)

        for model_class in self.all_model_classes:
           _UpperCAmelCase											=      True
           self.check_hidden_states_output(_UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase				)

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

           self.check_hidden_states_output(_UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase				)





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase					,			_UpperCAmelCase											=      self.model_tester.prepare_config_and_inputs_for_common()
        _UpperCAmelCase											=      3

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

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

        for model_class in self.all_model_classes:
           _UpperCAmelCase											=      True
           self.check_hidden_states_output(_UpperCamelCase							,       _UpperCamelCase							,       _UpperCamelCase							,       (padded_height, padded_width)				)

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





     @slow
     def 		UpperCamelCase(    self				):
        for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase											=      TFSwinModel.from_pretrained(_UpperCamelCase				)
           self.assertIsNotNone(_UpperCamelCase				)




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





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





     @slow
     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
        _UpperCAmelCase											=      self.default_image_processor

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

        # forward pass
        _UpperCAmelCase											=      model(_UpperCamelCase				)

        # verify the logits
        _UpperCAmelCase											=      tf.TensorShape((1, 1000)				)
        self.assertEqual(outputs.logits.shape							,       _UpperCamelCase				)
        _UpperCAmelCase											=      tf.constant([-0.0948, -0.6454, -0.0921]				)
        self.assertTrue(np.allclose(outputs.logits[0, :3]							,       _UpperCamelCase							,       atol=1e-4				)				)






from typing import TYPE_CHECKING

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


UpperCAmelCase_											=  {
    "configuration_oneformer": ["ONEFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "OneFormerConfig"],
    "processing_oneformer": ["OneFormerProcessor"],
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_											=  ["OneFormerImageProcessor"]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_											=  [
       "ONEFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
       "OneFormerForUniversalSegmentation",
       "OneFormerModel",
       "OneFormerPreTrainedModel",
   ]

if TYPE_CHECKING:
   from .configuration_oneformer import ONEFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, OneFormerConfig
   from .processing_oneformer import OneFormerProcessor

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_oneformer import OneFormerImageProcessor
   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_oneformer import (
          ONEFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          OneFormerForUniversalSegmentation,
          OneFormerModel,
          OneFormerPreTrainedModel,
      )


else:
   import sys

   UpperCAmelCase_											=  _LazyModule(__name__, globals()["__file__"], _import_structure)