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   lowerCamelCase					:
  """simple docstring"""







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







  def    __A     (							self :       str   )  ->	str:
        SCREAMING_SNAKE_CASE_          =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

        SCREAMING_SNAKE_CASE_          =  self.get_config()

        return config, pixel_values, labels







  def    __A     (							self :       List[Any]   )  ->	int:
        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    __A     (							self :       List[str]  ,     __magic_name__ :       List[Any]  ,     __magic_name__ :       Dict  ,     __magic_name__ :       str   )  ->	int:
        SCREAMING_SNAKE_CASE_          =  MaskFormerSwinModel(config=__magic_name__   )
        model.to(__magic_name__   )
        model.eval()
        SCREAMING_SNAKE_CASE_          =  model(__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
        SCREAMING_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    __A     (							self :       Optional[Any]  ,     __magic_name__ :       Optional[int]  ,     __magic_name__ :       Tuple  ,     __magic_name__ :       Optional[int]   )  ->	Optional[Any]:
        SCREAMING_SNAKE_CASE_          =  MaskFormerSwinBackbone(config=__magic_name__   )
        model.to(__magic_name__   )
        model.eval()
        SCREAMING_SNAKE_CASE_          =  model(__magic_name__   )

        # 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(__magic_name__   ):
              SCREAMING_SNAKE_CASE_          =  ["stem"]
              SCREAMING_SNAKE_CASE_          =  MaskFormerSwinBackbone(config=__magic_name__   )







  def    __A     (							self :       Optional[int]   )  ->	Any:
        SCREAMING_SNAKE_CASE_          =  self.prepare_config_and_inputs()
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  config_and_inputs
        SCREAMING_SNAKE_CASE_          =  {"pixel_values": pixel_values}
        return config, inputs_dict



@require_torch
class   lowerCamelCase					(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      unittest.TestCase					):
  """simple docstring"""







  lowerCamelCase__     =						(
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  lowerCamelCase__     =						{'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
  lowerCamelCase__     =						False
  lowerCamelCase__     =						False
  lowerCamelCase__     =						False
  lowerCamelCase__     =						False
  lowerCamelCase__     =						False







  def    __A     (							self :       Any   )  ->	int:
        SCREAMING_SNAKE_CASE_          =  MaskFormerSwinModelTester(self   )
        SCREAMING_SNAKE_CASE_          =  ConfigTester(self  ,     config_class=__magic_name__  ,     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    __A     (							self :       Optional[int]   )  ->	List[Any]:
        pass







  def    __A     (							self :       Optional[int]   )  ->	Tuple:
        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 :       Any   )  ->	Optional[int]:
        return







  def    __A     (							self :       Optional[Any]   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__magic_name__   )







  def    __A     (							self :       str   )  ->	Optional[int]:
        SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*__magic_name__   )







  @unittest.skip("Swin does not use inputs_embeds"   )
  def    __A     (							self :       Optional[int]   )  ->	str:
        pass







  @unittest.skip("Swin does not support feedforward chunking"   )
  def    __A     (							self :       Union[str, Any]   )  ->	str:
        pass







  def    __A     (							self :       str   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()

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







  def    __A     (							self :       List[Any]   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()

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

              SCREAMING_SNAKE_CASE_          =  ["pixel_values"]
              self.assertListEqual(arg_names[:1]  ,     __magic_name__   )







  @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions"   )
  def    __A     (							self :       str   )  ->	int:
        pass







  @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone"   )
  def    __A     (							self :       Optional[Any]   )  ->	Union[str, Any]:
        pass







  def    __A     (							self :       Dict  ,     __magic_name__ :       List[str]  ,     __magic_name__ :       Optional[Any]  ,     __magic_name__ :       Optional[int]  ,     __magic_name__ :       int   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_          =  model_class(__magic_name__   )
        model.to(__magic_name__   )
        model.eval()

        with torch.no_grad():
              SCREAMING_SNAKE_CASE_          =  model(**self._prepare_for_class(__magic_name__  ,     __magic_name__   )   )

        SCREAMING_SNAKE_CASE_          =  outputs.hidden_states

        SCREAMING_SNAKE_CASE_          =  getattr(
            self.model_tester  ,     "expected_num_hidden_layers"  ,     len(self.model_tester.depths   ) + 1   )
        self.assertEqual(len(__magic_name__   )  ,     __magic_name__   )

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

        SCREAMING_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]  ,     )







  def    __A     (							self :       Dict   )  ->	str:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()

        SCREAMING_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:
              SCREAMING_SNAKE_CASE_          =  True
              self.check_hidden_states_output(__magic_name__  ,     __magic_name__  ,     __magic_name__  ,     __magic_name__   )

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

              self.check_hidden_states_output(__magic_name__  ,     __magic_name__  ,     __magic_name__  ,     __magic_name__   )







  def    __A     (							self :       Tuple   )  ->	List[str]:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE_          =  3

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

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

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_          =  True
              self.check_hidden_states_output(__magic_name__  ,     __magic_name__  ,     __magic_name__  ,     (padded_height, padded_width)   )

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







  @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints"   )
  def    __A     (							self :       Tuple   )  ->	Optional[int]:
        pass







  @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"   )
  def    __A     (							self :       str   )  ->	Tuple:
        pass







  @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"   )
  def    __A     (							self :       int   )  ->	Any:
        pass







  def    __A     (							self :       Any   )  ->	Any:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()

        def set_nan_tensor_to_zero(__magic_name__ :       Dict   ):
              SCREAMING_SNAKE_CASE_          =  0
              return t

        def check_equivalence(__magic_name__ :       List[str]  ,     __magic_name__ :       List[Any]  ,     __magic_name__ :       Union[str, Any]  ,     __magic_name__ :       List[str]={}   ):
              with torch.no_grad():
                    SCREAMING_SNAKE_CASE_          =  model(**__magic_name__  ,     return_dict=__magic_name__  ,     **__magic_name__   )
                    SCREAMING_SNAKE_CASE_          =  model(**__magic_name__  ,     return_dict=__magic_name__  ,     **__magic_name__   ).to_tuple()

                    def recursive_check(__magic_name__ :       Optional[Any]  ,     __magic_name__ :       Any   ):
                          if isinstance(__magic_name__  ,     (List, Tuple)   ):
                                for tuple_iterable_value, dict_iterable_value in zip(__magic_name__  ,     __magic_name__   ):
                                      recursive_check(__magic_name__  ,     __magic_name__   )
                          elif isinstance(__magic_name__  ,     __magic_name__   ):
                                for tuple_iterable_value, dict_iterable_value in zip(
                                    tuple_object.values()  ,     dict_object.values()   ):
                                      recursive_check(__magic_name__  ,     __magic_name__   )
                          elif tuple_object is None:
                                return
                          else:
                                self.assertTrue(
                                    torch.allclose(
                                        set_nan_tensor_to_zero(__magic_name__   )  ,     set_nan_tensor_to_zero(__magic_name__   )  ,     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(__magic_name__   ).any()} and `inf`: {torch.isinf(__magic_name__   )}. Dict has'''
                                        F''' `nan`: {torch.isnan(__magic_name__   ).any()} and `inf`: {torch.isinf(__magic_name__   )}.'''
                                    )  ,     )

                    recursive_check(__magic_name__  ,     __magic_name__   )

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_          =  model_class(__magic_name__   )
              model.to(__magic_name__   )
              model.eval()

              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__   )
              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__   )
              check_equivalence(__magic_name__  ,     __magic_name__  ,     __magic_name__   )

              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__  ,     return_labels=__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__  ,     return_labels=__magic_name__   )
              check_equivalence(__magic_name__  ,     __magic_name__  ,     __magic_name__   )

              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__   )
              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__   )
              check_equivalence(__magic_name__  ,     __magic_name__  ,     __magic_name__  ,     {"output_hidden_states": True}   )

              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__  ,     return_labels=__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  self._prepare_for_class(__magic_name__  ,     __magic_name__  ,     return_labels=__magic_name__   )
              check_equivalence(__magic_name__  ,     __magic_name__  ,     __magic_name__  ,     {"output_hidden_states": True}   )



@require_torch
class   lowerCamelCase					(unittest.TestCase  ,      SCREAMING_SNAKE_CASE__					):
  """simple docstring"""







  lowerCamelCase__     =						(MaskFormerSwinBackbone,) if is_torch_available() else ()
  lowerCamelCase__     =						MaskFormerSwinConfig







  def    __A     (							self :       Union[str, Any]   )  ->	int:
        SCREAMING_SNAKE_CASE_          =  MaskFormerSwinModelTester(self   )







  def    __A     (							self :       Optional[Any]   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE_          =  inputs_dict["pixel_values"].shape[0]

        for backbone_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_          =  backbone_class(__magic_name__   )
              backbone.to(__magic_name__   )
              backbone.eval()

              SCREAMING_SNAKE_CASE_          =  backbone(**__magic_name__   )

              # Test default outputs and verify feature maps
              self.assertIsInstance(outputs.feature_maps  ,     __magic_name__   )
              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
              SCREAMING_SNAKE_CASE_          =  backbone(**__magic_name__  ,     output_hidden_states=__magic_name__   )
              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)
                          SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  hidden_state.shape
                          self.assertTrue((h_batch_size, h_n_channels)  ,     (batch_size, n_channels)   )

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



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


A     :  Dict					     =       {}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A     :  Optional[Any]					     =       ["BartphoTokenizer"]

if TYPE_CHECKING:
      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_bartpho import BartphoTokenizer

else:
      import sys

      A     :  Optional[int]					     =       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


