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


						def __init__(       self	:				str    ,		UpperCamelCase__	:				Optional[Any]    ,		UpperCamelCase__	:				Optional[int]=13    ,		UpperCamelCase__	:				str=32    ,		UpperCamelCase__	:				Optional[Any]=2    ,		UpperCamelCase__	:				Any=3    ,		UpperCamelCase__	:				Union[str, Any]=16    ,		UpperCamelCase__	:				Tuple=[1, 2, 1]    ,		UpperCamelCase__	:				int=[2, 2, 4]    ,		UpperCamelCase__	:				Union[str, Any]=2    ,		UpperCamelCase__	:				Any=2.0    ,		UpperCamelCase__	:				Dict=True    ,		UpperCamelCase__	:				Any=0.0    ,		UpperCamelCase__	:				Dict=0.0    ,		UpperCamelCase__	:				Any=0.1    ,		UpperCamelCase__	:				Optional[int]="gelu"    ,		UpperCamelCase__	:				List[str]=False    ,		UpperCamelCase__	:				Union[str, Any]=True    ,		UpperCamelCase__	:				Tuple=0.02    ,		UpperCamelCase__	:				Union[str, Any]=1E-5    ,		UpperCamelCase__	:				str=True    ,		UpperCamelCase__	:				Any=None    ,		UpperCamelCase__	:				Optional[Any]=True    ,		UpperCamelCase__	:				Any=10    ,		UpperCamelCase__	:				Any=8    ,		UpperCamelCase__	:				List[Any]=["stage1", "stage2", "stage3"]    ,		UpperCamelCase__	:				List[Any]=[1, 2, 3]    ,		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							parent
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							batch_size
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							image_size
												SCREAMING_SNAKE_CASE							:    str							=							patch_size
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							num_channels
												SCREAMING_SNAKE_CASE							:    str							=							embed_dim
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							depths
												SCREAMING_SNAKE_CASE							:    int							=							num_heads
												SCREAMING_SNAKE_CASE							:    str							=							window_size
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							mlp_ratio
												SCREAMING_SNAKE_CASE							:    List[str]							=							qkv_bias
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							hidden_dropout_prob
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							drop_path_rate
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							hidden_act
												SCREAMING_SNAKE_CASE							:    Dict							=							use_absolute_embeddings
												SCREAMING_SNAKE_CASE							:    List[str]							=							patch_norm
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							layer_norm_eps
												SCREAMING_SNAKE_CASE							:    int							=							initializer_range
												SCREAMING_SNAKE_CASE							:    Dict							=							is_training
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							scope
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							use_labels
												SCREAMING_SNAKE_CASE							:    List[Any]							=							type_sequence_label_size
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							encoder_stride
												SCREAMING_SNAKE_CASE							:    int							=							out_features
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							out_indices


						def        __A       (       self	:				Any						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

												SCREAMING_SNAKE_CASE							:    List[Any]							=							None
												if self.use_labels:
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							ids_tensor([self.batch_size]    ,		self.type_sequence_label_size						)

												SCREAMING_SNAKE_CASE							:    int							=							self.get_config()

												return config, pixel_values, labels


						def        __A       (       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        __A       (       self	:				Dict    ,		UpperCamelCase__	:				List[Any]    ,		UpperCamelCase__	:				List[Any]    ,		UpperCamelCase__	:				str						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[int]							=							MaskFormerSwinModel(config=UpperCamelCase__						)
												model.to(UpperCamelCase__						)
												model.eval()
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							model(UpperCamelCase__						)

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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							MaskFormerSwinBackbone(config=UpperCamelCase__						)
												model.to(UpperCamelCase__						)
												model.eval()
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							model(UpperCamelCase__						)

												# 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(UpperCamelCase__						):
																		SCREAMING_SNAKE_CASE							:    Tuple							=							['''stem''']
																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							MaskFormerSwinBackbone(config=UpperCamelCase__						)



						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Any							=							self.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Dict							=							config_and_inputs
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							{'''pixel_values''': pixel_values}
												return config, inputs_dict






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


						def        __A       (       self	:				List[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Dict							=							MaskFormerSwinModelTester(self						)
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							ConfigTester(self    ,		config_class=UpperCamelCase__    ,		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]						):





												'''simple docstring'''





												pass


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





												'''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        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												return


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Any							=							self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*UpperCamelCase__						)


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    int							=							self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*UpperCamelCase__						)


						@unittest.skip('''Swin does not use inputs_embeds'''						)
						def        __A       (       self	:				List[Any]						):





												'''simple docstring'''





												pass


						@unittest.skip('''Swin does not support feedforward chunking'''						)
						def        __A       (       self	:				List[str]						):





												'''simple docstring'''





												pass


						def        __A       (       self	:				int						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    List[str]							=							self.model_tester.prepare_config_and_inputs_for_common()

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


						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    int							=							self.model_tester.prepare_config_and_inputs_for_common()

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

																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							['''pixel_values''']
																		self.assertListEqual(arg_names[:1]    ,		UpperCamelCase__						)


						@unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'''						)
						def        __A       (       self	:				Union[str, Any]						):





												'''simple docstring'''





												pass


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





												'''simple docstring'''





												pass


						def        __A       (       self	:				int    ,		UpperCamelCase__	:				Tuple    ,		UpperCamelCase__	:				str    ,		UpperCamelCase__	:				List[str]    ,		UpperCamelCase__	:				Dict						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							model_class(UpperCamelCase__						)
												model.to(UpperCamelCase__						)
												model.eval()

												with torch.no_grad():
																		SCREAMING_SNAKE_CASE							:    Dict							=							model(**self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__						)						)

												SCREAMING_SNAKE_CASE							:    List[Any]							=							outputs.hidden_states

												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							getattr(
												    self.model_tester    ,		'''expected_num_hidden_layers'''    ,		len(self.model_tester.depths						) + 1						)
												self.assertEqual(len(UpperCamelCase__						)    ,		UpperCamelCase__						)

												# Swin has a different seq_length
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							(
												    config.patch_size
												    if isinstance(config.patch_size    ,		collections.abc.Iterable						)
												    else (config.patch_size, config.patch_size)
												)

												SCREAMING_SNAKE_CASE							:    Any							=							(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	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    List[Any]							=							self.model_tester.prepare_config_and_inputs_for_common()

												SCREAMING_SNAKE_CASE							:    str							=							(
												    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							:    List[str]							=							True
																		self.check_hidden_states_output(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__						)

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		SCREAMING_SNAKE_CASE							:    Tuple							=							True

																		self.check_hidden_states_output(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__						)


						def        __A       (       self	:				Dict						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Optional[Any]							=							self.model_tester.prepare_config_and_inputs_for_common()
												SCREAMING_SNAKE_CASE							:    List[str]							=							3

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

												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

												for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE							:    str							=							True
																		self.check_hidden_states_output(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		(padded_height, padded_width)						)

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		SCREAMING_SNAKE_CASE							:    Any							=							True
																		self.check_hidden_states_output(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		(padded_height, padded_width)						)


						@unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''						)
						def        __A       (       self	:				str						):





												'''simple docstring'''





												pass


						@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''						)
						def        __A       (       self	:				Union[str, Any]						):





												'''simple docstring'''





												pass


						@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''						)
						def        __A       (       self	:				Dict						):





												'''simple docstring'''





												pass



						def        __A       (       self	:				int						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Dict							=							self.model_tester.prepare_config_and_inputs_for_common()

												def set_nan_tensor_to_zero(UpperCamelCase__	:				Tuple						):
																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							0
																		return t

												def check_equivalence(UpperCamelCase__	:				Dict    ,		UpperCamelCase__	:				List[Any]    ,		UpperCamelCase__	:				Union[str, Any]    ,		UpperCamelCase__	:				Tuple={}						):
																		with torch.no_grad():
																								SCREAMING_SNAKE_CASE							:    List[str]							=							model(**UpperCamelCase__    ,		return_dict=UpperCamelCase__    ,		**UpperCamelCase__						)
																								SCREAMING_SNAKE_CASE							:    int							=							model(**UpperCamelCase__    ,		return_dict=UpperCamelCase__    ,		**UpperCamelCase__						).to_tuple()

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

																								recursive_check(UpperCamelCase__    ,		UpperCamelCase__						)

												for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE							:    Dict							=							model_class(UpperCamelCase__						)
																		model.to(UpperCamelCase__						)
																		model.eval()

																		SCREAMING_SNAKE_CASE							:    Optional[int]							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__						)
																		check_equivalence(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    str							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__    ,		return_labels=UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__    ,		return_labels=UpperCamelCase__						)
																		check_equivalence(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    Tuple							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    Any							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__						)
																		check_equivalence(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		{'''output_hidden_states''': True}						)

																		SCREAMING_SNAKE_CASE							:    str							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__    ,		return_labels=UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    List[str]							=							self._prepare_for_class(UpperCamelCase__    ,		UpperCamelCase__    ,		return_labels=UpperCamelCase__						)
																		check_equivalence(UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		{'''output_hidden_states''': True}						)






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


						def        __A       (       self	:				Tuple						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							MaskFormerSwinModelTester(self						)



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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Tuple							=							self.model_tester.prepare_config_and_inputs_for_common()
												SCREAMING_SNAKE_CASE							:    List[str]							=							inputs_dict['''pixel_values'''].shape[0]

												for backbone_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE							:    int							=							backbone_class(UpperCamelCase__						)
																		backbone.to(UpperCamelCase__						)
																		backbone.eval()

																		SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							backbone(**UpperCamelCase__						)

																		# Test default outputs and verify feature maps
																		self.assertIsInstance(outputs.feature_maps    ,		UpperCamelCase__						)
																		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							:    Union[str, Any]							=							backbone(**UpperCamelCase__    ,		output_hidden_states=UpperCamelCase__						)
																		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							:    List[str]							=							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							:    Union[str, Any]							=							backbone(**UpperCamelCase__    ,		output_attentions=UpperCamelCase__						)
																								self.assertIsNotNone(outputs.attentions						)






from packaging import version

from .import_utils import is_accelerate_available


if is_accelerate_available():
					import accelerate
def       A	(    _lowercase						):
						if not is_accelerate_available():
												return method
						SCREAMING_SNAKE_CASE							:    int							=							version.parse(accelerate.__version__						).base_version
						if version.parse(_lowercase						) < version.parse('''0.17.0'''						):
												return method

						def wrapper(self		,  *_lowercase		,  **_lowercase						):
												if hasattr(self		,  '''_hf_hook'''						) and hasattr(self._hf_hook		,  '''pre_forward'''						):
																		self._hf_hook.pre_forward(self						)
												return method(self		,  *_lowercase		,  **_lowercase						)

						return wrapper





