



import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roberta import RobertaTokenizer


UpperCamelCase__ =						logging.get_logger(__name__)

UpperCamelCase__ =						{"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

UpperCamelCase__ =						{
    "vocab_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/vocab.json",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/vocab.json",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/vocab.json",
        "roberta-base-openai-detector": "https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json",
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json"
        ),
    },
    "merges_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/merges.txt",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/merges.txt",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/merges.txt",
        "roberta-base-openai-detector": "https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt",
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt"
        ),
    },
    "tokenizer_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/tokenizer.json",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/tokenizer.json",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/tokenizer.json",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/tokenizer.json",
        "roberta-base-openai-detector": (
            "https://huggingface.co/roberta-base-openai-detector/resolve/main/tokenizer.json"
        ),
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/tokenizer.json"
        ),
    },
}

UpperCamelCase__ =						{
    "roberta-base": 5_12,
    "roberta-large": 5_12,
    "roberta-large-mnli": 5_12,
    "distilroberta-base": 5_12,
    "roberta-base-openai-detector": 5_12,
    "roberta-large-openai-detector": 5_12,
}
class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  Dict      =			VOCAB_FILES_NAMES
			lowercase__      :  str      =			PRETRAINED_VOCAB_FILES_MAP
			lowercase__      :  Tuple      =			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			lowercase__      :  Optional[Any]      =			["""input_ids""", """attention_mask"""]
			lowercase__      :  Tuple      =			RobertaTokenizer





			def __init__(				self	:       Dict			,     lowercase	:       Optional[int]=None			,     lowercase	:       Union[str, Any]=None			,     lowercase	:       Tuple=None			,     lowercase	:       Optional[int]="replace"			,     lowercase	:       Union[str, Any]="<s>"			,     lowercase	:       Optional[Any]="</s>"			,     lowercase	:       Union[str, Any]="</s>"			,     lowercase	:       List[Any]="<s>"			,     lowercase	:       Optional[Any]="<unk>"			,     lowercase	:       List[Any]="<pad>"			,     lowercase	:       List[str]="<mask>"			,     lowercase	:       Optional[Any]=False			,     lowercase	:       Dict=True			,     **lowercase	:       str			,     )						->					Tuple:
									"""simple docstring"""







									super().__init__(
									    lowercase			,     lowercase			,     tokenizer_file=lowercase			,     errors=lowercase			,     bos_token=lowercase			,     eos_token=lowercase			,     sep_token=lowercase			,     cls_token=lowercase			,     unk_token=lowercase			,     pad_token=lowercase			,     mask_token=lowercase			,     add_prefix_space=lowercase			,     trim_offsets=lowercase			,     **lowercase			,     )

									__lowercase					=				json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()   )
									if pre_tok_state.get("""add_prefix_space"""			,     lowercase   ) != add_prefix_space:
															__lowercase					=				getattr(lowercase			,     pre_tok_state.pop("""type"""   )   )
															__lowercase					=				add_prefix_space
															__lowercase					=				pre_tok_class(**lowercase   )

									__lowercase					=				add_prefix_space

									__lowercase					=				"""post_processor"""
									__lowercase					=				getattr(self.backend_tokenizer			,     lowercase			,     lowercase   )
									if tokenizer_component_instance:
															__lowercase					=				json.loads(tokenizer_component_instance.__getstate__()   )

															# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
															if "sep" in state:
																					__lowercase					=				tuple(state["""sep"""]   )
															if "cls" in state:
																					__lowercase					=				tuple(state["""cls"""]   )

															__lowercase					=				False

															if state.get("""add_prefix_space"""			,     lowercase   ) != add_prefix_space:
																					__lowercase					=				add_prefix_space
																					__lowercase					=				True

															if state.get("""trim_offsets"""			,     lowercase   ) != trim_offsets:
																					__lowercase					=				trim_offsets
																					__lowercase					=				True

															if changes_to_apply:
																					__lowercase					=				getattr(lowercase			,     state.pop("""type"""   )   )
																					__lowercase					=				component_class(**lowercase   )
																					setattr(self.backend_tokenizer			,     lowercase			,     lowercase   )





			@property
			def 		snake_case__			(				self	:       Any   )						->					str:
									"""simple docstring"""







									if self._mask_token is None:
															if self.verbose:
																					logger.error("""Using mask_token, but it is not set yet."""   )
															return None
									return str(self._mask_token   )





			@mask_token.setter
			def 		snake_case__			(				self	:       Any			,     lowercase	:       Tuple   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase					=				AddedToken(lowercase			,     lstrip=lowercase			,     rstrip=lowercase   ) if isinstance(lowercase			,     lowercase   ) else value
									__lowercase					=				value





			def 		snake_case__			(				self	:       List[Any]			,     *lowercase	:       Tuple			,     **lowercase	:       Dict   )						->					BatchEncoding:
									"""simple docstring"""







									__lowercase					=				kwargs.get("""is_split_into_words"""			,     lowercase   )
									assert self.add_prefix_space or not is_split_into_words, (
									    F"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
									    "to use it with pretokenized inputs."
									)

									return super()._batch_encode_plus(*lowercase			,     **lowercase   )





			def 		snake_case__			(				self	:       Any			,     *lowercase	:       int			,     **lowercase	:       Optional[int]   )						->					BatchEncoding:
									"""simple docstring"""







									__lowercase					=				kwargs.get("""is_split_into_words"""			,     lowercase   )

									assert self.add_prefix_space or not is_split_into_words, (
									    F"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
									    "to use it with pretokenized inputs."
									)

									return super()._encode_plus(*lowercase			,     **lowercase   )





			def 		snake_case__			(				self	:       int			,     lowercase	:       str			,     lowercase	:       Optional[str] = None   )						->					Tuple[str]:
									"""simple docstring"""







									__lowercase					=				self._tokenizer.model.save(lowercase			,     name=lowercase   )
									return tuple(lowercase   )





			def 		snake_case__			(				self	:       Tuple			,     lowercase	:       Dict			,     lowercase	:       Optional[Any]=None   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				[self.bos_token_id] + token_ids_a + [self.eos_token_id]
									if token_ids_a is None:
															return output

									return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]







			def 		snake_case__			(				self	:       Tuple			,     lowercase	:       List[int]			,     lowercase	:       Optional[List[int]] = None   )						->					List[int]:
									"""simple docstring"""







									__lowercase					=				[self.sep_token_id]
									__lowercase					=				[self.cls_token_id]

									if token_ids_a is None:
															return len(cls + token_ids_a + sep   ) * [0]
									return len(cls + token_ids_a + sep + sep + token_ids_a + sep   ) * [0]










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	:       List[Any]			,     lowercase	:       str			,     lowercase	:       Union[str, Any]=13			,     lowercase	:       Tuple=32			,     lowercase	:       Optional[Any]=2			,     lowercase	:       Tuple=3			,     lowercase	:       Tuple=16			,     lowercase	:       Tuple=[1, 2, 1]			,     lowercase	:       Optional[Any]=[2, 2, 4]			,     lowercase	:       Dict=2			,     lowercase	:       Optional[int]=2.0			,     lowercase	:       List[Any]=True			,     lowercase	:       str=0.0			,     lowercase	:       Any=0.0			,     lowercase	:       Optional[int]=0.1			,     lowercase	:       int="gelu"			,     lowercase	:       Tuple=False			,     lowercase	:       Optional[Any]=True			,     lowercase	:       int=0.02			,     lowercase	:       Union[str, Any]=1E-5			,     lowercase	:       Dict=True			,     lowercase	:       Any=None			,     lowercase	:       str=True			,     lowercase	:       str=10			,     lowercase	:       Dict=8			,     lowercase	:       int=["stage1", "stage2", "stage3"]			,     lowercase	:       Optional[int]=[1, 2, 3]			,     )						->					Any:
									"""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 		snake_case__			(				self	:       str   )						->					Union[str, 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 		snake_case__			(				self	:       List[str]   )						->					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 		snake_case__			(				self	:       Any			,     lowercase	:       List[Any]			,     lowercase	:       Optional[int]			,     lowercase	:       Optional[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									__lowercase					=				MaskFormerSwinModel(config=lowercase   )
									model.to(lowercase   )
									model.eval()
									__lowercase					=				model(lowercase   )

									__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 		snake_case__			(				self	:       Any			,     lowercase	:       Tuple			,     lowercase	:       Any			,     lowercase	:       Optional[int]   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				MaskFormerSwinBackbone(config=lowercase   )
									model.to(lowercase   )
									model.eval()
									__lowercase					=				model(lowercase   )

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







			def 		snake_case__			(				self	:       int   )						->					Any:
									"""simple docstring"""







									__lowercase					=				self.prepare_config_and_inputs()
									__lowercase	,			__lowercase	,			__lowercase					=				config_and_inputs
									__lowercase					=				{"""pixel_values""": pixel_values}
									return config, inputs_dict





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






			"""simple docstring"""





			lowercase__      :  Optional[int]      =			(
			    (
			        MaskFormerSwinModel,
			        MaskFormerSwinBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			lowercase__      :  List[str]      =			{"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
			lowercase__      :  List[str]      =			False
			lowercase__      :  int      =			False
			lowercase__      :  int      =			False
			lowercase__      :  Tuple      =			False
			lowercase__      :  Optional[Any]      =			False





			def 		snake_case__			(				self	:       Dict   )						->					Optional[Any]:
									"""simple docstring"""







									__lowercase					=				MaskFormerSwinModelTester(self   )
									__lowercase					=				ConfigTester(self			,     config_class=lowercase			,     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 		snake_case__			(				self	:       Tuple   )						->					List[str]:
									"""simple docstring"""







									pass





			def 		snake_case__			(				self	:       Tuple   )						->					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 		snake_case__			(				self	:       Optional[Any]   )						->					Dict:
									"""simple docstring"""







									return





			def 		snake_case__			(				self	:       Tuple   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowercase   )





			def 		snake_case__			(				self	:       List[str]   )						->					Tuple:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*lowercase   )





			@unittest.skip("""Swin does not use inputs_embeds"""   )
			def 		snake_case__			(				self	:       int   )						->					Any:
									"""simple docstring"""







									pass





			@unittest.skip("""Swin does not support feedforward chunking"""   )
			def 		snake_case__			(				self	:       Optional[int]   )						->					Union[str, Any]:
									"""simple docstring"""







									pass





			def 		snake_case__			(				self	:       Dict   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()

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





			def 		snake_case__			(				self	:       Dict   )						->					Any:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()

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





			@unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""   )
			def 		snake_case__			(				self	:       Any   )						->					Union[str, Any]:
									"""simple docstring"""







									pass





			@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""   )
			def 		snake_case__			(				self	:       Tuple   )						->					Optional[Any]:
									"""simple docstring"""







									pass





			def 		snake_case__			(				self	:       Tuple			,     lowercase	:       Tuple			,     lowercase	:       Optional[int]			,     lowercase	:       Optional[int]			,     lowercase	:       Union[str, Any]   )						->					Dict:
									"""simple docstring"""







									__lowercase					=				model_class(lowercase   )
									model.to(lowercase   )
									model.eval()

									with torch.no_grad():
															__lowercase					=				model(**self._prepare_for_class(lowercase			,     lowercase   )   )

									__lowercase					=				outputs.hidden_states

									__lowercase					=				getattr(
									    self.model_tester			,     """expected_num_hidden_layers"""			,     len(self.model_tester.depths   ) + 1   )
									self.assertEqual(len(lowercase   )			,     lowercase   )

									# 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 		snake_case__			(				self	:       int   )						->					Dict:
									"""simple docstring"""







									__lowercase	,			__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(lowercase			,     lowercase			,     lowercase			,     lowercase   )

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

															self.check_hidden_states_output(lowercase			,     lowercase			,     lowercase			,     lowercase   )





			def 		snake_case__			(				self	:       int   )						->					str:
									"""simple docstring"""







									__lowercase	,			__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(lowercase			,     lowercase			,     lowercase			,     (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(lowercase			,     lowercase			,     lowercase			,     (padded_height, padded_width)   )





			@unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""   )
			def 		snake_case__			(				self	:       Any   )						->					Any:
									"""simple docstring"""







									pass





			@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""   )
			def 		snake_case__			(				self	:       List[str]   )						->					str:
									"""simple docstring"""







									pass





			@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""   )
			def 		snake_case__			(				self	:       str   )						->					Union[str, Any]:
									"""simple docstring"""







									pass







			def 		snake_case__			(				self	:       Tuple   )						->					List[Any]:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()

									def set_nan_tensor_to_zero(lowercase	:       Optional[int]   ):
															__lowercase					=				0
															return t

									def check_equivalence(lowercase	:       Optional[int]			,     lowercase	:       str			,     lowercase	:       str			,     lowercase	:       Tuple={}   ):
															with torch.no_grad():
																					__lowercase					=				model(**lowercase			,     return_dict=lowercase			,     **lowercase   )
																					__lowercase					=				model(**lowercase			,     return_dict=lowercase			,     **lowercase   ).to_tuple()

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

																					recursive_check(lowercase			,     lowercase   )

									for model_class in self.all_model_classes:
															__lowercase					=				model_class(lowercase   )
															model.to(lowercase   )
															model.eval()

															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase   )
															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase   )
															check_equivalence(lowercase			,     lowercase			,     lowercase   )

															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase			,     return_labels=lowercase   )
															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase			,     return_labels=lowercase   )
															check_equivalence(lowercase			,     lowercase			,     lowercase   )

															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase   )
															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase   )
															check_equivalence(lowercase			,     lowercase			,     lowercase			,     {"""output_hidden_states""": True}   )

															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase			,     return_labels=lowercase   )
															__lowercase					=				self._prepare_for_class(lowercase			,     lowercase			,     return_labels=lowercase   )
															check_equivalence(lowercase			,     lowercase			,     lowercase			,     {"""output_hidden_states""": True}   )





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






			"""simple docstring"""





			lowercase__      :  List[str]      =			(MaskFormerSwinBackbone,) if is_torch_available() else ()
			lowercase__      :  Any      =			MaskFormerSwinConfig





			def 		snake_case__			(				self	:       Union[str, Any]   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				MaskFormerSwinModelTester(self   )







			def 		snake_case__			(				self	:       Any   )						->					Tuple:
									"""simple docstring"""







									__lowercase	,			__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(lowercase   )
															backbone.to(lowercase   )
															backbone.eval()

															__lowercase					=				backbone(**lowercase   )

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





