





'''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      UpperCamelCase__					:




					"""simple docstring"""


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

							'''simple docstring'''



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


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[Any]		=			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 :				str		=			self.get_config()

							return config, pixel_values, labels


					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''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 lowerCamelCase_			(						self				:			str      ,						lowerCamelCase_				:			List[Any]      ,						lowerCamelCase_				:			Union[str, Any]      ,						lowerCamelCase_				:			Any						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[int]		=			MaskFormerSwinModel(config=lowerCamelCase_						)
							model.to(lowerCamelCase_						)
							model.eval()
							SCREAMING_SNAKE_CASE :				Tuple		=			model(lowerCamelCase_						)

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

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Tuple		=			MaskFormerSwinBackbone(config=lowerCamelCase_						)
							model.to(lowerCamelCase_						)
							model.eval()
							SCREAMING_SNAKE_CASE :				Optional[int]		=			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						)      ,						[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(lowerCamelCase_						):
									SCREAMING_SNAKE_CASE :				Optional[int]		=			["""stem"""]
									SCREAMING_SNAKE_CASE :				Dict		=			MaskFormerSwinBackbone(config=lowerCamelCase_						)



					def lowerCamelCase_			(						self				:			Any						):

							'''simple docstring'''



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







@require_torch
class      UpperCamelCase__					(					lowercase_						,					lowercase_						,					unittest.TestCase			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	(
					    (
					        MaskFormerSwinModel,
					        MaskFormerSwinBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE__				=	{'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
					SCREAMING_SNAKE_CASE__				=	False
					SCREAMING_SNAKE_CASE__				=	False
					SCREAMING_SNAKE_CASE__				=	False
					SCREAMING_SNAKE_CASE__				=	False
					SCREAMING_SNAKE_CASE__				=	False


					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			MaskFormerSwinModelTester(self						)
							SCREAMING_SNAKE_CASE :				Any		=			ConfigTester(self      ,						config_class=lowerCamelCase_      ,						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 lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



							pass


					def lowerCamelCase_			(						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 lowerCamelCase_			(						self				:			Optional[int]						):

							'''simple docstring'''



							return


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



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


					@unittest.skip("""Swin does not use inputs_embeds"""						)
					def lowerCamelCase_			(						self				:			Any						):

							'''simple docstring'''



							pass


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

							'''simple docstring'''



							pass


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



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

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


					def lowerCamelCase_			(						self				:			Any						):

							'''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 :				List[Any]		=			model_class(lowerCamelCase_						)
									SCREAMING_SNAKE_CASE :				List[str]		=			inspect.signature(model.forward						)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									SCREAMING_SNAKE_CASE :				Union[str, Any]		=			[*signature.parameters.keys()]

									SCREAMING_SNAKE_CASE :				int		=			["""pixel_values"""]
									self.assertListEqual(arg_names[:1]      ,						lowerCamelCase_						)


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

							'''simple docstring'''



							pass


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

							'''simple docstring'''



							pass


					def lowerCamelCase_			(						self				:			Optional[int]      ,						lowerCamelCase_				:			Tuple      ,						lowerCamelCase_				:			Optional[Any]      ,						lowerCamelCase_				:			Tuple      ,						lowerCamelCase_				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				str		=			model_class(lowerCamelCase_						)
							model.to(lowerCamelCase_						)
							model.eval()

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

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			outputs.hidden_states

							SCREAMING_SNAKE_CASE :				str		=			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
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			(
							    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[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 lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



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

							SCREAMING_SNAKE_CASE :				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)
							)

							for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE :				str		=			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"]
									SCREAMING_SNAKE_CASE :				List[Any]		=			True

									self.check_hidden_states_output(lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			Tuple						):

							'''simple docstring'''



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

							SCREAMING_SNAKE_CASE :				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)
							)
							SCREAMING_SNAKE_CASE :				List[str]		=			(
							    config.patch_size
							    if isinstance(config.patch_size      ,						collections.abc.Iterable						)
							    else (config.patch_size, config.patch_size)
							)

							SCREAMING_SNAKE_CASE :				int		=			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							SCREAMING_SNAKE_CASE :				int		=			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(lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_      ,						(padded_height, padded_width)						)

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


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

							'''simple docstring'''



							pass


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

							'''simple docstring'''



							pass


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

							'''simple docstring'''



							pass



					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



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

							def set_nan_tensor_to_zero(lowerCamelCase_				:			Tuple						):
									SCREAMING_SNAKE_CASE :				Union[str, Any]		=			0
									return t

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

											def recursive_check(lowerCamelCase_				:			List[Any]      ,						lowerCamelCase_				:			Dict						):
													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:
									SCREAMING_SNAKE_CASE :				Any		=			model_class(lowerCamelCase_						)
									model.to(lowerCamelCase_						)
									model.eval()

									SCREAMING_SNAKE_CASE :				Dict		=			self._prepare_for_class(lowerCamelCase_      ,						lowerCamelCase_						)
									SCREAMING_SNAKE_CASE :				Dict		=			self._prepare_for_class(lowerCamelCase_      ,						lowerCamelCase_						)
									check_equivalence(lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_						)

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

									SCREAMING_SNAKE_CASE :				Optional[int]		=			self._prepare_for_class(lowerCamelCase_      ,						lowerCamelCase_						)
									SCREAMING_SNAKE_CASE :				List[Any]		=			self._prepare_for_class(lowerCamelCase_      ,						lowerCamelCase_						)
									check_equivalence(lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_      ,						{"""output_hidden_states""": True}						)

									SCREAMING_SNAKE_CASE :				Union[str, Any]		=			self._prepare_for_class(lowerCamelCase_      ,						lowerCamelCase_      ,						return_labels=lowerCamelCase_						)
									SCREAMING_SNAKE_CASE :				Dict		=			self._prepare_for_class(lowerCamelCase_      ,						lowerCamelCase_      ,						return_labels=lowerCamelCase_						)
									check_equivalence(lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_      ,						{"""output_hidden_states""": True}						)







@require_torch
class      UpperCamelCase__					(					unittest.TestCase						,					lowercase_			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	(MaskFormerSwinBackbone,) if is_torch_available() else ()
					SCREAMING_SNAKE_CASE__				=	MaskFormerSwinConfig


					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			MaskFormerSwinModelTester(self						)



					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE :				List[str]		=			self.model_tester.prepare_config_and_inputs_for_common()
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			inputs_dict["""pixel_values"""].shape[0]

							for backbone_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE :				Optional[Any]		=			backbone_class(lowerCamelCase_						)
									backbone.to(lowerCamelCase_						)
									backbone.eval()

									SCREAMING_SNAKE_CASE :				Dict		=			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
									SCREAMING_SNAKE_CASE :				Dict		=			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)
													SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE :				int		=			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(**lowerCamelCase_      ,						output_attentions=lowerCamelCase_						)
											self.assertIsNotNone(outputs.attentions						)










'''simple docstring'''




from __future__ import annotations



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		if partitions <= 0:
				raise ValueError("""partitions must be a positive number!"""	)
		if partitions > number_of_bytes:
				raise ValueError("""partitions can not > number_of_bytes!"""	)
		SCREAMING_SNAKE_CASE :				int		=			number_of_bytes // partitions
		SCREAMING_SNAKE_CASE :				int		=			[]
		for i in range(lowerCamelCase_	):
				SCREAMING_SNAKE_CASE :				Optional[Any]		=			i * bytes_per_partition + 1
				SCREAMING_SNAKE_CASE :				Optional[int]		=			(
				    number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition
				)
				allocation_list.append(f'''{start_bytes}-{end_bytes}'''	)
		return allocation_list


if __name__ == "__main__":
							import doctest

							doctest.testmod()



