





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    :

  """simple docstring"""


  def __init__(				self :		Any					,  lowerCAmelCase_ :		Union[str, Any]					,  lowerCAmelCase_ :		Any=1_3					,  lowerCAmelCase_ :		Optional[Any]=3_2					,  lowerCAmelCase_ :		Any=2					,  lowerCAmelCase_ :		int=3					,  lowerCAmelCase_ :		Tuple=1_6					,  lowerCAmelCase_ :		Optional[Any]=[1, 2, 1]					,  lowerCAmelCase_ :		List[str]=[2, 2, 4]					,  lowerCAmelCase_ :		Tuple=2					,  lowerCAmelCase_ :		Tuple=2.0					,  lowerCAmelCase_ :		str=True					,  lowerCAmelCase_ :		int=0.0					,  lowerCAmelCase_ :		Dict=0.0					,  lowerCAmelCase_ :		Union[str, Any]=0.1					,  lowerCAmelCase_ :		str="gelu"					,  lowerCAmelCase_ :		Optional[int]=False					,  lowerCAmelCase_ :		Any=True					,  lowerCAmelCase_ :		str=0.02					,  lowerCAmelCase_ :		List[Any]=1e-5					,  lowerCAmelCase_ :		List[Any]=True					,  lowerCAmelCase_ :		str=None					,  lowerCAmelCase_ :		str=True					,  lowerCAmelCase_ :		Optional[int]=1_0					,  lowerCAmelCase_ :		str=8					,  lowerCAmelCase_ :		Optional[int]=["stage1", "stage2", "stage3"]					,  lowerCAmelCase_ :		Optional[Any]=[1, 2, 3]					,  )							->						int:
     __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 				lowercase		(				self :		Optional[int]     )							->						Optional[Any]:
     __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 				lowercase		(				self :		List[Any]     )							->						Any:
     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 				lowercase		(				self :		Tuple					,  lowerCAmelCase_ :		Tuple					,  lowerCAmelCase_ :		str					,  lowerCAmelCase_ :		Any     )							->						Union[str, Any]:
     __lowerCAmelCase								=	MaskFormerSwinModel(config=lowerCAmelCase_     )
     model.to(lowerCAmelCase_     )
     model.eval()
     __lowerCAmelCase								=	model(lowerCAmelCase_     )

     __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 				lowercase		(				self :		str					,  lowerCAmelCase_ :		List[str]					,  lowerCAmelCase_ :		Optional[Any]					,  lowerCAmelCase_ :		int     )							->						List[str]:
     __lowerCAmelCase								=	MaskFormerSwinBackbone(config=lowerCAmelCase_     )
     model.to(lowerCAmelCase_     )
     model.eval()
     __lowerCAmelCase								=	model(lowerCAmelCase_     )

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

     # verify channels
     self.parent.assertEqual(len(model.channels     )					,  len(config.out_features     )     )
     self.parent.assertListEqual(model.channels					,  [1_6, 3_2, 6_4]     )

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






  def 				lowercase		(				self :		int     )							->						Dict:
     __lowerCAmelCase								=	self.prepare_config_and_inputs()
     __lowerCAmelCase	,	__lowerCAmelCase	,	__lowerCAmelCase								=	config_and_inputs
     __lowerCAmelCase								=	{'pixel_values': pixel_values}
     return config, inputs_dict





@require_torch
class 				_UpperCAmelCase    (    _UpperCamelCase		,    _UpperCamelCase		,    unittest.TestCase    ):

  """simple docstring"""


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






  def 				lowercase		(				self :		List[Any]     )							->						int:
     __lowerCAmelCase								=	MaskFormerSwinModelTester(self     )
     __lowerCAmelCase								=	ConfigTester(self					,  config_class=lowerCAmelCase_					,  embed_dim=3_7     )






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






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






  def 				lowercase		(				self :		Optional[int]     )							->						List[Any]:
     __lowerCAmelCase								=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase_     )






  def 				lowercase		(				self :		int     )							->						Optional[Any]:
     __lowerCAmelCase								=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*lowerCAmelCase_     )






  @unittest.skip('Swin does not use inputs_embeds'     )
  def 				lowercase		(				self :		List[str]     )							->						int:
     pass






  @unittest.skip('Swin does not support feedforward chunking'     )
  def 				lowercase		(				self :		List[str]     )							->						Tuple:
     pass






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

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






  def 				lowercase		(				self :		Dict     )							->						Optional[Any]:
     __lowerCAmelCase	,	__lowerCAmelCase								=	self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __lowerCAmelCase								=	model_class(lowerCAmelCase_     )
        __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]					,  lowerCAmelCase_     )






  @unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'     )
  def 				lowercase		(				self :		List[str]     )							->						List[str]:
     pass






  @unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'     )
  def 				lowercase		(				self :		int     )							->						List[str]:
     pass






  def 				lowercase		(				self :		Union[str, Any]					,  lowerCAmelCase_ :		Tuple					,  lowerCAmelCase_ :		List[str]					,  lowerCAmelCase_ :		int					,  lowerCAmelCase_ :		Any     )							->						Optional[Any]:
     __lowerCAmelCase								=	model_class(lowerCAmelCase_     )
     model.to(lowerCAmelCase_     )
     model.eval()

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

     __lowerCAmelCase								=	outputs.hidden_states

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

     # 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 				lowercase		(				self :		Dict     )							->						str:
     __lowerCAmelCase	,	__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(lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_     )

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

        self.check_hidden_states_output(lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_     )






  def 				lowercase		(				self :		Tuple     )							->						Optional[int]:
     __lowerCAmelCase	,	__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(lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_					,  (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(lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_					,  (padded_height, padded_width)     )






  @unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'     )
  def 				lowercase		(				self :		List[Any]     )							->						Optional[Any]:
     pass






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






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






  def 				lowercase		(				self :		Any     )							->						Optional[Any]:
     __lowerCAmelCase	,	__lowerCAmelCase								=	self.model_tester.prepare_config_and_inputs_for_common()

     def set_nan_tensor_to_zero(lowerCAmelCase_ :		Union[str, Any]     ):
        __lowerCAmelCase								=	0
        return t

     def check_equivalence(lowerCAmelCase_ :		Optional[int]					,  lowerCAmelCase_ :		List[Any]					,  lowerCAmelCase_ :		Any					,  lowerCAmelCase_ :		Optional[int]={}     ):
        with torch.no_grad():
           __lowerCAmelCase								=	model(**lowerCAmelCase_					,  return_dict=lowerCAmelCase_					,  **lowerCAmelCase_     )
           __lowerCAmelCase								=	model(**lowerCAmelCase_					,  return_dict=lowerCAmelCase_					,  **lowerCAmelCase_     ).to_tuple()

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

           recursive_check(lowerCAmelCase_					,  lowerCAmelCase_     )

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

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

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

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

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





@require_torch
class 				_UpperCAmelCase    (    unittest.TestCase		,    _UpperCamelCase    ):

  """simple docstring"""


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






  def 				lowercase		(				self :		Optional[Any]     )							->						List[str]:
     __lowerCAmelCase								=	MaskFormerSwinModelTester(self     )






  def 				lowercase		(				self :		List[Any]     )							->						int:
     __lowerCAmelCase	,	__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(lowerCAmelCase_     )
        backbone.to(lowerCAmelCase_     )
        backbone.eval()

        __lowerCAmelCase								=	backbone(**lowerCAmelCase_     )

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps					,  lowerCAmelCase_     )
        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(**lowerCAmelCase_					,  output_hidden_states=lowerCAmelCase_     )
        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	,	__lowerCAmelCase	,	__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(**lowerCAmelCase_					,  output_attentions=lowerCAmelCase_     )
           self.assertIsNotNone(outputs.attentions     )








import re

from filelock import FileLock


try:
     import nltk

     _snake_case  :    Any						    =  True
except (ImportError, ModuleNotFoundError):
     _snake_case  :    Union[str, Any]						    =  False

if NLTK_AVAILABLE:
     with FileLock('.lock') as lock:
          nltk.download('punkt', quiet=True)

def   a_    ( lowerCAmelCase_      :			str	):
   re.sub('<n>',	'',	lowerCAmelCase_	)  # remove pegasus newline char
   assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)"
   return "\n".join(nltk.sent_tokenize(lowerCAmelCase_	)	)

