


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

		"""simple docstring"""





		def __init__( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__=13					,				SCREAMING_SNAKE_CASE__=32					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=3					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=[1, 2, 1]					,				SCREAMING_SNAKE_CASE__=[2, 2, 4]					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=2.0					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.1					,				SCREAMING_SNAKE_CASE__="gelu"					,				SCREAMING_SNAKE_CASE__=False					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=0.0_2					,				SCREAMING_SNAKE_CASE__=1E-5					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=None					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=10					,				SCREAMING_SNAKE_CASE__=8					,				SCREAMING_SNAKE_CASE__=["stage1", "stage2", "stage3"]					,				SCREAMING_SNAKE_CASE__=[1, 2, 3]					,				)      ->	Any:

					"""simple docstring"""



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

					"""simple docstring"""



					_UpperCamelCase					:Tuple					     =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

					_UpperCamelCase					:Dict					     =	self.get_config()

					return config, pixel_values, labels
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



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

					"""simple docstring"""



					_UpperCamelCase					:int					     =	MaskFormerSwinModel(config=SCREAMING_SNAKE_CASE__   )
					model.to(SCREAMING_SNAKE_CASE__   )
					model.eval()
					_UpperCamelCase					:Optional[int]					     =	model(SCREAMING_SNAKE_CASE__   )

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

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	MaskFormerSwinBackbone(config=SCREAMING_SNAKE_CASE__   )
					model.to(SCREAMING_SNAKE_CASE__   )
					model.eval()
					_UpperCamelCase					:str					     =	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__   ):
								_UpperCamelCase					:Optional[Any]					     =	['''stem''']
								_UpperCamelCase					:int					     =	MaskFormerSwinBackbone(config=SCREAMING_SNAKE_CASE__   )





		def   _UpperCamelCase( self   )      ->	Any:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	self.prepare_config_and_inputs()
					_UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase					:int					     =	config_and_inputs
					_UpperCamelCase					:Any					     =	{'''pixel_values''': pixel_values}
					return config, inputs_dict






@require_torch
class      A(  lowerCamelCase__				,							lowerCamelCase__				,							unittest.TestCase		):

		"""simple docstring"""





		A    =							(
		    (
		        MaskFormerSwinModel,
		        MaskFormerSwinBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		A    =							{"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
		A    =							False
		A    =							False
		A    =							False
		A    =							False
		A    =							False
		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	MaskFormerSwinModelTester(self   )
					_UpperCamelCase					:List[str]					     =	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   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					pass
		def   _UpperCamelCase( self   )      ->	List[str]:

					"""simple docstring"""



					self.create_and_test_config_common_properties()
					self.config_tester.create_and_test_config_to_json_string()
					self.config_tester.create_and_test_config_to_json_file()
					self.config_tester.create_and_test_config_from_and_save_pretrained()
					self.config_tester.create_and_test_config_with_num_labels()
					self.config_tester.check_config_can_be_init_without_params()
					self.config_tester.check_config_arguments_init()
		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					return
		def   _UpperCamelCase( self   )      ->	Any:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__   )
		def   _UpperCamelCase( self   )      ->	Union[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	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   _UpperCamelCase( self   )      ->	Any:

					"""simple docstring"""



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

					"""simple docstring"""



					pass
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



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

					for model_class in self.all_model_classes:
								_UpperCamelCase					:Union[str, Any]					     =	model_class(SCREAMING_SNAKE_CASE__   )
								self.assertIsInstance(model.get_input_embeddings()					,				(nn.Module)   )
								_UpperCamelCase					:str					     =	model.get_output_embeddings()
								self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__					,				nn.Linear   )   )
		def   _UpperCamelCase( self   )      ->	List[str]:

					"""simple docstring"""



					_UpperCamelCase     ,      _UpperCamelCase					:Optional[int]					     =	self.model_tester.prepare_config_and_inputs_for_common()

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

								_UpperCamelCase					:Tuple					     =	['''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   _UpperCamelCase( self   )      ->	str:

					"""simple docstring"""



					pass
		@unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone'''   )
		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					pass
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	model_class(SCREAMING_SNAKE_CASE__   )
					model.to(SCREAMING_SNAKE_CASE__   )
					model.eval()

					with torch.no_grad():
								_UpperCamelCase					:Optional[int]					     =	model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )   )

					_UpperCamelCase					:List[str]					     =	outputs.hidden_states

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

					_UpperCamelCase					:Tuple					     =	(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

					self.assertListEqual(
					    list(hidden_states[0].shape[-2:]   )					,				[num_patches, self.model_tester.embed_dim]					,				)
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase     ,      _UpperCamelCase					:str					     =	self.model_tester.prepare_config_and_inputs_for_common()

					_UpperCamelCase					:Optional[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)
					)

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

								self.check_hidden_states_output(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase     ,      _UpperCamelCase					:int					     =	self.model_tester.prepare_config_and_inputs_for_common()
					_UpperCamelCase					:List[Any]					     =	3

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

					_UpperCamelCase					:Optional[Any]					     =	image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
					_UpperCamelCase					:List[Any]					     =	image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

					for model_class in self.all_model_classes:
								_UpperCamelCase					:Tuple					     =	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"]
								_UpperCamelCase					:List[Any]					     =	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   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



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

					"""simple docstring"""



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

					"""simple docstring"""



					pass





		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase     ,      _UpperCamelCase					:str					     =	self.model_tester.prepare_config_and_inputs_for_common()

					def set_nan_tensor_to_zero(SCREAMING_SNAKE_CASE__   ):
								_UpperCamelCase					:Optional[int]					     =	0
								return t

					def check_equivalence(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__={}   ):
								with torch.no_grad():
											_UpperCamelCase					:int					     =	model(**SCREAMING_SNAKE_CASE__					,				return_dict=SCREAMING_SNAKE_CASE__					,				**SCREAMING_SNAKE_CASE__   )
											_UpperCamelCase					:Any					     =	model(**SCREAMING_SNAKE_CASE__					,				return_dict=SCREAMING_SNAKE_CASE__					,				**SCREAMING_SNAKE_CASE__   ).to_tuple()

											def recursive_check(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   ):
														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:
								_UpperCamelCase					:Any					     =	model_class(SCREAMING_SNAKE_CASE__   )
								model.to(SCREAMING_SNAKE_CASE__   )
								model.eval()

								_UpperCamelCase					:Tuple					     =	self._prepare_for_class(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Dict					     =	self._prepare_for_class(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
								check_equivalence(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

								_UpperCamelCase					:Optional[Any]					     =	self._prepare_for_class(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				return_labels=SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:List[str]					     =	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__   )

								_UpperCamelCase					:Union[str, Any]					     =	self._prepare_for_class(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					: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}   )

								_UpperCamelCase					:Any					     =	self._prepare_for_class(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				return_labels=SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:str					     =	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      A(  unittest.TestCase				,							lowerCamelCase__		):

		"""simple docstring"""





		A    =							(MaskFormerSwinBackbone,) if is_torch_available() else ()
		A    =							MaskFormerSwinConfig
		def   _UpperCamelCase( self   )      ->	List[str]:

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	MaskFormerSwinModelTester(self   )





		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					_UpperCamelCase     ,      _UpperCamelCase					:List[Any]					     =	self.model_tester.prepare_config_and_inputs_for_common()
					_UpperCamelCase					:Union[str, Any]					     =	inputs_dict['''pixel_values'''].shape[0]

					for backbone_class in self.all_model_classes:
								_UpperCamelCase					:str					     =	backbone_class(SCREAMING_SNAKE_CASE__   )
								backbone.to(SCREAMING_SNAKE_CASE__   )
								backbone.eval()

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

            # Test output_attentions=True
								if self.has_attentions:
											_UpperCamelCase					:str					     =	backbone(**SCREAMING_SNAKE_CASE__					,				output_attentions=SCREAMING_SNAKE_CASE__   )
											self.assertIsNotNone(outputs.attentions   )





"""simple docstring"""






import os





def 				A_       ( )					->  Any:
			with open(os.path.dirname(snake_case__		) + '''/p022_names.txt'''		) as file:
						_UpperCamelCase					:Optional[Any]					     =	str(file.readlines()[0]		)
						_UpperCamelCase					:Dict					     =	names.replace('''"'''       ,					''''''		).split(''','''		)

			names.sort()

			_UpperCamelCase					:str					     =	0
			_UpperCamelCase					:Union[str, Any]					     =	0

			for i, name in enumerate(snake_case__		):
						for letter in name:
									name_score += ord(snake_case__		) - 64

						total_score += (i + 1) * name_score
						_UpperCamelCase					:List[Any]					     =	0
			return total_score


if __name__ == "__main__":
					print(solution())

