



"""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  SCREAMING_SNAKE_CASE__			:

    def __init__(					self      :					Tuple			,	lowerCAmelCase_      :					Optional[int]			,	lowerCAmelCase_      :					Tuple=1_3			,	lowerCAmelCase_      :					Any=3_2			,	lowerCAmelCase_      :					int=2			,	lowerCAmelCase_      :					List[Any]=3			,	lowerCAmelCase_      :					Union[str, Any]=1_6			,	lowerCAmelCase_      :					Optional[int]=[1, 2, 1]			,	lowerCAmelCase_      :					List[Any]=[2, 2, 4]			,	lowerCAmelCase_      :					Optional[Any]=2			,	lowerCAmelCase_      :					Dict=2.0			,	lowerCAmelCase_      :					Optional[Any]=True			,	lowerCAmelCase_      :					Optional[int]=0.0			,	lowerCAmelCase_      :					Union[str, Any]=0.0			,	lowerCAmelCase_      :					str=0.1			,	lowerCAmelCase_      :					List[str]="gelu"			,	lowerCAmelCase_      :					List[Any]=False			,	lowerCAmelCase_      :					str=True			,	lowerCAmelCase_      :					Optional[int]=0.02			,	lowerCAmelCase_      :					Any=1E-5			,	lowerCAmelCase_      :					List[Any]=True			,	lowerCAmelCase_      :					Optional[int]=None			,	lowerCAmelCase_      :					int=True			,	lowerCAmelCase_      :					Optional[Any]=1_0			,	lowerCAmelCase_      :					str=8			,	lowerCAmelCase_      :					List[Any]=["stage1", "stage2", "stage3"]			,	lowerCAmelCase_      :					List[str]=[1, 2, 3]			,	):







      """simple docstring"""







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

    def        _UpperCAmelCase						(					self      :					Any):







      """simple docstring"""







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

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

      lowercase_             =			self.get_config()

      return config, pixel_values, labels

    def        _UpperCAmelCase						(					self      :					int):







      """simple docstring"""







      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      :					Optional[Any]			,	lowerCAmelCase_      :					str			,	lowerCAmelCase_      :					int			,	lowerCAmelCase_      :					List[Any]):







      """simple docstring"""







      lowercase_             =			MaskFormerSwinModel(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_             =			model(lowerCAmelCase_)

      lowercase_             =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
      lowercase_             =			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      :					str			,	lowerCAmelCase_      :					List[str]			,	lowerCAmelCase_      :					Union[str, Any]			,	lowerCAmelCase_      :					int):







      """simple docstring"""







      lowercase_             =			MaskFormerSwinBackbone(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_             =			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_):
        lowercase_             =			['''stem''']
        lowercase_             =			MaskFormerSwinBackbone(config=lowerCAmelCase_)




    def        _UpperCAmelCase						(					self      :					str):







      """simple docstring"""







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







@require_torch
class  SCREAMING_SNAKE_CASE__			(				__snake_case   ,	__snake_case   ,	unittest.TestCase ):
    lowercase__  			= (
        (
            MaskFormerSwinModel,
            MaskFormerSwinBackbone,
        )
        if is_torch_available()
        else ()
    )
    lowercase__  			= {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
    lowercase__  			= False
    lowercase__  			= False
    lowercase__  			= False
    lowercase__  			= False
    lowercase__  			= False

    def        _UpperCAmelCase						(					self      :					Dict):







      """simple docstring"""







      lowercase_             =			MaskFormerSwinModelTester(self)
      lowercase_             =			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        _UpperCAmelCase						(					self      :					List[str]):







      """simple docstring"""







      pass

    def        _UpperCAmelCase						(					self      :					str):







      """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        _UpperCAmelCase						(					self      :					Dict):







      """simple docstring"""







      return

    def        _UpperCAmelCase						(					self      :					Union[str, Any]):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_)

    def        _UpperCAmelCase						(					self      :					Any):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowerCAmelCase_)

    @unittest.skip("""Swin does not use inputs_embeds""")
    def        _UpperCAmelCase						(					self      :					Union[str, Any]):







      """simple docstring"""







      pass

    @unittest.skip("""Swin does not support feedforward chunking""")
    def        _UpperCAmelCase						(					self      :					Optional[int]):







      """simple docstring"""







      pass

    def        _UpperCAmelCase						(					self      :					int):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs_for_common()

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

    def        _UpperCAmelCase						(					self      :					Optional[Any]):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs_for_common()

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

        lowercase_             =			['''pixel_values''']
        self.assertListEqual(arg_names[:1]			,	lowerCAmelCase_)

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







      """simple docstring"""







      pass

    @unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone""")
    def        _UpperCAmelCase						(					self      :					List[str]):







      """simple docstring"""







      pass

    def        _UpperCAmelCase						(					self      :					Union[str, Any]			,	lowerCAmelCase_      :					Optional[Any]			,	lowerCAmelCase_      :					int			,	lowerCAmelCase_      :					str			,	lowerCAmelCase_      :					Optional[Any]):







      """simple docstring"""







      lowercase_             =			model_class(lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()

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

      lowercase_             =			outputs.hidden_states

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

      lowercase_             =			(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      :					int):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs_for_common()

      lowercase_             =			(
          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:
        lowercase_             =			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"]
        lowercase_             =			True

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

    def        _UpperCAmelCase						(					self      :					Tuple):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs_for_common()
      lowercase_             =			3

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

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

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

    @unittest.skip(reason="""MaskFormerSwin doesn\'t have pretrained checkpoints""")
    def        _UpperCAmelCase						(					self      :					Optional[Any]):







      """simple docstring"""







      pass

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







      """simple docstring"""







      pass

    @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin""")
    def        _UpperCAmelCase						(					self      :					Optional[Any]):







      """simple docstring"""







      pass




    def        _UpperCAmelCase						(					self      :					Union[str, Any]):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs_for_common()

      def set_nan_tensor_to_zero(lowerCAmelCase_      :					Tuple):
        lowercase_             =			0
        return t

      def check_equivalence(lowerCAmelCase_      :					Any			,	lowerCAmelCase_      :					Dict			,	lowerCAmelCase_      :					List[str]			,	lowerCAmelCase_      :					str={}):
        with torch.no_grad():
          lowercase_             =			model(**lowerCAmelCase_			,	return_dict=lowerCAmelCase_			,	**lowerCAmelCase_)
          lowercase_             =			model(**lowerCAmelCase_			,	return_dict=lowerCAmelCase_			,	**lowerCAmelCase_).to_tuple()

          def recursive_check(lowerCAmelCase_      :					Any			,	lowerCAmelCase_      :					Optional[Any]):
            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:
        lowercase_             =			model_class(lowerCAmelCase_)
        model.to(lowerCAmelCase_)
        model.eval()

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

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

        lowercase_             =			self._prepare_for_class(lowerCAmelCase_			,	lowerCAmelCase_)
        lowercase_             =			self._prepare_for_class(lowerCAmelCase_			,	lowerCAmelCase_)
        check_equivalence(lowerCAmelCase_			,	lowerCAmelCase_			,	lowerCAmelCase_			,	{"""output_hidden_states""": True})

        lowercase_             =			self._prepare_for_class(lowerCAmelCase_			,	lowerCAmelCase_			,	return_labels=lowerCAmelCase_)
        lowercase_             =			self._prepare_for_class(lowerCAmelCase_			,	lowerCAmelCase_			,	return_labels=lowerCAmelCase_)
        check_equivalence(lowerCAmelCase_			,	lowerCAmelCase_			,	lowerCAmelCase_			,	{"""output_hidden_states""": True})







@require_torch
class  SCREAMING_SNAKE_CASE__			(				unittest.TestCase   ,	__snake_case ):
    lowercase__  			= (MaskFormerSwinBackbone,) if is_torch_available() else ()
    lowercase__  			= MaskFormerSwinConfig

    def        _UpperCAmelCase						(					self      :					Dict):







      """simple docstring"""







      lowercase_             =			MaskFormerSwinModelTester(self)




    def        _UpperCAmelCase						(					self      :					str):







      """simple docstring"""







      lowercase_             =			self.model_tester.prepare_config_and_inputs_for_common()
      lowercase_             =			inputs_dict['''pixel_values'''].shape[0]

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

        lowercase_             =			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
        lowercase_             =			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)
            lowercase_             =			hidden_state.shape
            self.assertTrue((h_batch_size, h_n_channels)			,	(batch_size, n_channels))

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



'''simple docstring'''




# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from ..utils import cached_file


# docstyle-ignore
lowercase     :							Tuple       						=     '\nHuman: <<task>>\n\nAssistant: '


lowercase     :							Union[str, Any]       						=     'huggingface-tools/default-prompts'
lowercase     :							int       						=     {'chat': 'chat_prompt_template.txt', 'run': 'run_prompt_template.txt'}







def 						lowerCAmelCase_							(  snake_case__						,							snake_case__						,							snake_case__="run"		):




    '''simple docstring'''



    if prompt_or_repo_id is None:
        A			:  List[Any]   =		DEFAULT_PROMPTS_REPO

    # prompt is considered a repo ID when it does not contain any kind of space
    if re.search('''\\s'''						,							snake_case__		) is not None:
        return prompt_or_repo_id

    A			:  int   =		cached_file(
        snake_case__						,							PROMPT_FILES[mode]						,							repo_type='''dataset'''						,							user_agent={'''agent''': agent_name}		)
    with open(snake_case__						,							'''r'''						,							encoding='''utf-8'''		) as f:
        return f.read()




