






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






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]					)			->			str:
							a_		:  List[Any]											=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

							a_		:  Optional[int]											=      None
							if self.use_labels:
											a_		:  Any											=      ids_tensor([self.batch_size]  ,						self.type_sequence_label_size					)

							a_		:  List[str]											=      self.get_config()

							return config, pixel_values, labels






			def 			SCREAMING_SNAKE_CASE      ( self      :			Any					)			->			Optional[int]:
							return MaskFormerSwinConfig(
							    image_size=self.image_size  ,						patch_size=self.patch_size  ,						num_channels=self.num_channels  ,						embed_dim=self.embed_dim  ,						depths=self.depths  ,						num_heads=self.num_heads  ,						window_size=self.window_size  ,						mlp_ratio=self.mlp_ratio  ,						qkv_bias=self.qkv_bias  ,						hidden_dropout_prob=self.hidden_dropout_prob  ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,						drop_path_rate=self.drop_path_rate  ,						hidden_act=self.hidden_act  ,						use_absolute_embeddings=self.use_absolute_embeddings  ,						path_norm=self.patch_norm  ,						layer_norm_eps=self.layer_norm_eps  ,						initializer_range=self.initializer_range  ,						encoder_stride=self.encoder_stride  ,						out_features=self.out_features  ,						out_indices=self.out_indices  ,						)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]  ,						__SCREAMING_SNAKE_CASE      :			Union[str, Any]  ,						__SCREAMING_SNAKE_CASE      :			Dict  ,						__SCREAMING_SNAKE_CASE      :			int					)			->			List[str]:
							a_		:  List[Any]											=      MaskFormerSwinModel(config=__SCREAMING_SNAKE_CASE					)
							model.to(__SCREAMING_SNAKE_CASE					)
							model.eval()
							a_		:  Optional[Any]											=      model(__SCREAMING_SNAKE_CASE					)

							a_		:  int											=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
							a_		:  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 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]  ,						__SCREAMING_SNAKE_CASE      :			Tuple  ,						__SCREAMING_SNAKE_CASE      :			Optional[int]  ,						__SCREAMING_SNAKE_CASE      :			int					)			->			List[Any]:
							a_		:  Union[str, Any]											=      MaskFormerSwinBackbone(config=__SCREAMING_SNAKE_CASE					)
							model.to(__SCREAMING_SNAKE_CASE					)
							model.eval()
							a_		:  Dict											=      model(__SCREAMING_SNAKE_CASE					)

							# 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(__SCREAMING_SNAKE_CASE					):
											a_		:  Tuple											=      ['''stem''']
											a_		:  str											=      MaskFormerSwinBackbone(config=__SCREAMING_SNAKE_CASE					)







			def 			SCREAMING_SNAKE_CASE      ( self      :			List[Any]					)			->			Union[str, Any]:
							a_		:  Any											=      self.prepare_config_and_inputs()
							a_				,			a_				,			a_		:  int											=      config_and_inputs
							a_		:  Tuple											=      {'''pixel_values''': pixel_values}
							return config, inputs_dict





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






			def 			SCREAMING_SNAKE_CASE      ( self      :			Dict					)			->			Optional[int]:
							a_		:  Dict											=      MaskFormerSwinModelTester(self					)
							a_		:  int											=      ConfigTester(self  ,						config_class=__SCREAMING_SNAKE_CASE  ,						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 			SCREAMING_SNAKE_CASE      ( self      :			Any					)			->			Dict:
							pass






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[int]					)			->			Tuple:
							self.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()






			def 			SCREAMING_SNAKE_CASE      ( self      :			Dict					)			->			Dict:
							return






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]					)			->			List[Any]:
							a_		:  Optional[Any]											=      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]					)			->			Optional[Any]:
							a_		:  str											=      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE					)






			@unittest.skip('''Swin does not use inputs_embeds'''					)
			def 			SCREAMING_SNAKE_CASE      ( self      :			Any					)			->			int:
							pass






			@unittest.skip('''Swin does not support feedforward chunking'''					)
			def 			SCREAMING_SNAKE_CASE      ( self      :			List[Any]					)			->			Optional[Any]:
							pass






			def 			SCREAMING_SNAKE_CASE      ( self      :			Tuple					)			->			str:
							a_				,			a_		:  str											=      self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											a_		:  Union[str, Any]											=      model_class(__SCREAMING_SNAKE_CASE					)
											self.assertIsInstance(model.get_input_embeddings()  ,						(nn.Module)					)
											a_		:  Optional[Any]											=      model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE  ,						nn.Linear					)					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			int					)			->			Dict:
							a_				,			a_		:  List[str]											=      self.model_tester.prepare_config_and_inputs_for_common()

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

											a_		:  Union[str, Any]											=      ['''pixel_values''']
											self.assertListEqual(arg_names[:1]  ,						__SCREAMING_SNAKE_CASE					)






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






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






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]  ,						__SCREAMING_SNAKE_CASE      :			str  ,						__SCREAMING_SNAKE_CASE      :			Optional[int]  ,						__SCREAMING_SNAKE_CASE      :			List[str]  ,						__SCREAMING_SNAKE_CASE      :			Dict					)			->			Optional[int]:
							a_		:  Optional[Any]											=      model_class(__SCREAMING_SNAKE_CASE					)
							model.to(__SCREAMING_SNAKE_CASE					)
							model.eval()

							with torch.no_grad():
											a_		:  Any											=      model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)					)

							a_		:  Union[str, Any]											=      outputs.hidden_states

							a_		:  Dict											=      getattr(
							    self.model_tester  ,						'''expected_num_hidden_layers'''  ,						len(self.model_tester.depths					) + 1					)
							self.assertEqual(len(__SCREAMING_SNAKE_CASE					)  ,						__SCREAMING_SNAKE_CASE					)

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

							a_		:  Union[str, 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 			SCREAMING_SNAKE_CASE      ( self      :			Optional[int]					)			->			List[str]:
							a_				,			a_		:  Tuple											=      self.model_tester.prepare_config_and_inputs_for_common()

							a_		:  List[Any]											=      (
							    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:
											a_		:  int											=      True
											self.check_hidden_states_output(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											a_		:  Optional[Any]											=      True

											self.check_hidden_states_output(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]					)			->			List[Any]:
							a_				,			a_		:  Union[str, Any]											=      self.model_tester.prepare_config_and_inputs_for_common()
							a_		:  int											=      3

							a_		:  Dict											=      (
							    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)
							)
							a_		:  Optional[Any]											=      (
							    config.patch_size
							    if isinstance(config.patch_size  ,						collections.abc.Iterable					)
							    else (config.patch_size, config.patch_size)
							)

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

							for model_class in self.all_model_classes:
											a_		:  Union[str, Any]											=      True
											self.check_hidden_states_output(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						(padded_height, padded_width)					)

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






			@unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''					)
			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			Any:
							pass






			@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''					)
			def 			SCREAMING_SNAKE_CASE      ( self      :			List[Any]					)			->			Any:
							pass






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







			def 			SCREAMING_SNAKE_CASE      ( self      :			List[str]					)			->			Optional[int]:
							a_				,			a_		:  List[Any]											=      self.model_tester.prepare_config_and_inputs_for_common()

							def set_nan_tensor_to_zero(__SCREAMING_SNAKE_CASE      :			Optional[Any]					):
											a_		:  str											=      0
											return t

							def check_equivalence(__SCREAMING_SNAKE_CASE      :			Any  ,						__SCREAMING_SNAKE_CASE      :			List[Any]  ,						__SCREAMING_SNAKE_CASE      :			Optional[int]  ,						__SCREAMING_SNAKE_CASE      :			Any={}					):
											with torch.no_grad():
															a_		:  Optional[Any]											=      model(**__SCREAMING_SNAKE_CASE  ,						return_dict=__SCREAMING_SNAKE_CASE  ,						**__SCREAMING_SNAKE_CASE					)
															a_		:  Union[str, Any]											=      model(**__SCREAMING_SNAKE_CASE  ,						return_dict=__SCREAMING_SNAKE_CASE  ,						**__SCREAMING_SNAKE_CASE					).to_tuple()

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

															recursive_check(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)

							for model_class in self.all_model_classes:
											a_		:  Union[str, Any]											=      model_class(__SCREAMING_SNAKE_CASE					)
											model.to(__SCREAMING_SNAKE_CASE					)
											model.eval()

											a_		:  List[str]											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)
											a_		:  Any											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)
											check_equivalence(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)

											a_		:  str											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						return_labels=__SCREAMING_SNAKE_CASE					)
											a_		:  int											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						return_labels=__SCREAMING_SNAKE_CASE					)
											check_equivalence(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)

											a_		:  Tuple											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)
											a_		:  Union[str, Any]											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					)
											check_equivalence(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						{'''output_hidden_states''': True}					)

											a_		:  Optional[int]											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						return_labels=__SCREAMING_SNAKE_CASE					)
											a_		:  List[Any]											=      self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						return_labels=__SCREAMING_SNAKE_CASE					)
											check_equivalence(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE  ,						{'''output_hidden_states''': True}					)





@require_torch
class 	SCREAMING_SNAKE_CASE					(					unittest.TestCase	,   SCREAMING_SNAKE_CASE_       ):
			snake_case__  =				(MaskFormerSwinBackbone,) if is_torch_available() else ()
			snake_case__  =				MaskFormerSwinConfig






			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			str:
							a_		:  List[Any]											=      MaskFormerSwinModelTester(self					)







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

							for backbone_class in self.all_model_classes:
											a_		:  int											=      backbone_class(__SCREAMING_SNAKE_CASE					)
											backbone.to(__SCREAMING_SNAKE_CASE					)
											backbone.eval()

											a_		:  List[Any]											=      backbone(**__SCREAMING_SNAKE_CASE					)

											# Test default outputs and verify feature maps
											self.assertIsInstance(outputs.feature_maps  ,						__SCREAMING_SNAKE_CASE					)
											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
											a_		:  List[Any]											=      backbone(**__SCREAMING_SNAKE_CASE  ,						output_hidden_states=__SCREAMING_SNAKE_CASE					)
											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)
																			a_				,			a_				,			a_		:  Optional[int]											=      hidden_state.shape
																			self.assertTrue((h_batch_size, h_n_channels)  ,						(batch_size, n_channels)					)

            # Test output_attentions=True
											if self.has_attentions:
															a_		:  Union[str, Any]											=      backbone(**__SCREAMING_SNAKE_CASE  ,						output_attentions=__SCREAMING_SNAKE_CASE					)
															self.assertIsNotNone(outputs.attentions					)












'''simple docstring'''







import warnings


warnings.warn(
    'memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: '
    '`from accelerate import find_executable_batch_size` to avoid this warning.',
    FutureWarning,
)




