


import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType



@require_torch
class 							a       :
     UpperCAmelCase__			:	int       =						()
     UpperCAmelCase__			:	str       =						True





     def 			SCREAMING_SNAKE_CASE__							(     self       :					List[Any]				):
        __lowerCamelCase:					Dict	 =						self.config_class

        # test default config
        __lowerCamelCase:					Optional[Any]	 =						config_class()
        self.assertIsNotNone(lowercase__				)
        __lowerCamelCase:					Union[str, Any]	 =						["""stem"""] + [F'stage{idx}' for idx in range(1     ,						len(config.depths				) + 1				)]
        self.assertEqual(config.stage_names     ,						lowercase__				)
        self.assertTrue(set(config.out_features				).issubset(set(config.stage_names				)				)				)

        # Test out_features and out_indices are correctly set
        # out_features and out_indices both None
        __lowerCamelCase:					int	 =						config_class(out_features=lowercase__     ,						out_indices=lowercase__				)
        self.assertEqual(config.out_features     ,						[config.stage_names[-1]]				)
        self.assertEqual(config.out_indices     ,						[len(config.stage_names				) - 1]				)

        # out_features and out_indices both set
        __lowerCamelCase:					List[Any]	 =						config_class(out_features=["""stem""", """stage1"""]     ,						out_indices=[0, 1]				)
        self.assertEqual(config.out_features     ,						["""stem""", """stage1"""]				)
        self.assertEqual(config.out_indices     ,						[0, 1]				)

        # Only out_features set
        __lowerCamelCase:					Optional[Any]	 =						config_class(out_features=["""stage1""", """stage3"""]				)
        self.assertEqual(config.out_features     ,						["""stage1""", """stage3"""]				)
        self.assertEqual(config.out_indices     ,						[1, 3]				)

        # Only out_indices set
        __lowerCamelCase:					List[str]	 =						config_class(out_indices=[0, 2]				)
        self.assertEqual(config.out_features     ,						[config.stage_names[0], config.stage_names[2]]				)
        self.assertEqual(config.out_indices     ,						[0, 2]				)

        # Error raised when out_indices do not correspond to out_features
        with self.assertRaises(lowercase__				):
           __lowerCamelCase:					Tuple	 =						config_class(out_features=["""stage1""", """stage2"""]     ,						out_indices=[0, 2]				)





     def 			SCREAMING_SNAKE_CASE__							(     self       :					int				):
        __lowerCamelCase ,  __lowerCamelCase:					Union[str, Any]	 =						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           __lowerCamelCase:					str	 =						model_class(lowercase__				)
           __lowerCamelCase:					List[str]	 =						inspect.signature(model.forward				)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           __lowerCamelCase:					Optional[int]	 =						[*signature.parameters.keys()]
           __lowerCamelCase:					Union[str, Any]	 =						["""pixel_values"""]
           self.assertListEqual(arg_names[:1]     ,						lowercase__				)





     def 			SCREAMING_SNAKE_CASE__							(     self       :					Tuple				):
        __lowerCamelCase ,  __lowerCamelCase:					str	 =						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           __lowerCamelCase:					Tuple	 =						model_class(lowercase__				)
           self.assertEqual(len(model.channels				)     ,						len(config.out_features				)				)
           __lowerCamelCase:					Dict	 =						model.num_features
           __lowerCamelCase:					List[Any]	 =						[config.stage_names.index(lowercase__				) for feat in config.out_features]
           __lowerCamelCase:					Dict	 =						[num_features[idx] for idx in out_indices]
           self.assertListEqual(model.channels     ,						lowercase__				)

           __lowerCamelCase:					Dict	 =						copy.deepcopy(lowercase__				)
           __lowerCamelCase:					Dict	 =						None
           __lowerCamelCase:					Any	 =						model_class(lowercase__				)
           self.assertEqual(len(model.channels				)     ,						1				)
           self.assertListEqual(model.channels     ,						[num_features[-1]]				)

           __lowerCamelCase:					Union[str, Any]	 =						copy.deepcopy(lowercase__				)
           __lowerCamelCase:					Union[str, Any]	 =						None
           __lowerCamelCase:					Tuple	 =						model_class(lowercase__				)
           self.assertEqual(len(model.channels				)     ,						1				)
           self.assertListEqual(model.channels     ,						[num_features[-1]]				)





     def 			SCREAMING_SNAKE_CASE__							(     self       :					List[Any]				):
        __lowerCamelCase ,  __lowerCamelCase:					Tuple	 =						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           __lowerCamelCase:					List[Any]	 =						model_class(lowercase__				)
           model.to(lowercase__				)
           model.eval()
           __lowerCamelCase:					List[str]	 =						model(**lowercase__				)

           self.assertEqual(len(result.feature_maps				)     ,						len(config.out_features				)				)
           self.assertEqual(len(model.channels				)     ,						len(config.out_features				)				)
           self.assertEqual(len(result.feature_maps				)     ,						len(config.out_indices				)				)
           self.assertEqual(len(model.channels				)     ,						len(config.out_indices				)				)

           # Check output of last stage is taken if out_features=None, out_indices=None
           __lowerCamelCase:					List[str]	 =						copy.deepcopy(lowercase__				)
           __lowerCamelCase:					Any	 =						None
           __lowerCamelCase:					Any	 =						model_class(lowercase__				)
           model.to(lowercase__				)
           model.eval()
           __lowerCamelCase:					Union[str, Any]	 =						model(**lowercase__				)

           self.assertEqual(len(result.feature_maps				)     ,						1				)
           self.assertEqual(len(model.channels				)     ,						1				)

           __lowerCamelCase:					Optional[int]	 =						copy.deepcopy(lowercase__				)
           __lowerCamelCase:					int	 =						None
           __lowerCamelCase:					Tuple	 =						model_class(lowercase__				)
           model.to(lowercase__				)
           model.eval()
           __lowerCamelCase:					Dict	 =						model(**lowercase__				)

           self.assertEqual(len(result.feature_maps				)     ,						1				)
           self.assertEqual(len(model.channels				)     ,						1				)

           # Check backbone can be initialized with fresh weights
           __lowerCamelCase:					List[str]	 =						copy.deepcopy(lowercase__				)
           __lowerCamelCase:					Any	 =						False
           __lowerCamelCase:					List[Any]	 =						model_class(lowercase__				)
           model.to(lowercase__				)
           model.eval()
           __lowerCamelCase:					str	 =						model(**lowercase__				)





     def 			SCREAMING_SNAKE_CASE__							(     self       :					Union[str, Any]				):
        __lowerCamelCase ,  __lowerCamelCase:					Tuple	 =						self.model_tester.prepare_config_and_inputs_for_common()

        for backbone_class in self.all_model_classes:
           __lowerCamelCase:					Any	 =						backbone_class(lowercase__				)

           self.assertTrue(hasattr(lowercase__     ,						"""backbone_type"""				)				)
           self.assertTrue(hasattr(lowercase__     ,						"""stage_names"""				)				)
           self.assertTrue(hasattr(lowercase__     ,						"""num_features"""				)				)
           self.assertTrue(hasattr(lowercase__     ,						"""out_indices"""				)				)
           self.assertTrue(hasattr(lowercase__     ,						"""out_features"""				)				)
           self.assertTrue(hasattr(lowercase__     ,						"""out_feature_channels"""				)				)
           self.assertTrue(hasattr(lowercase__     ,						"""channels"""				)				)

           self.assertIsInstance(backbone.backbone_type     ,						lowercase__				)
           # Verify num_features has been initialized in the backbone init
           self.assertIsNotNone(backbone.num_features				)
           self.assertTrue(len(backbone.channels				) == len(backbone.out_indices				)				)
           self.assertTrue(len(backbone.stage_names				) == len(backbone.num_features				)				)
           self.assertTrue(len(backbone.channels				) <= len(backbone.num_features				)				)
           self.assertTrue(len(backbone.out_feature_channels				) == len(backbone.stage_names				)				)







     def 			SCREAMING_SNAKE_CASE__							(     self       :					Union[str, Any]				):
        __lowerCamelCase ,  __lowerCamelCase:					str	 =						self.model_tester.prepare_config_and_inputs_for_common()
        __lowerCamelCase:					Union[str, Any]	 =						inputs_dict["""pixel_values"""].shape[0]

        for backbone_class in self.all_model_classes:
           __lowerCamelCase:					List[str]	 =						backbone_class(lowercase__				)
           backbone.to(lowercase__				)
           backbone.eval()

           __lowerCamelCase:					int	 =						backbone(**lowercase__				)

           # Test default outputs and verify feature maps
           self.assertIsInstance(outputs.feature_maps     ,						lowercase__				)
           self.assertTrue(len(outputs.feature_maps				) == len(backbone.channels				)				)
           for feature_map, n_channels in zip(outputs.feature_maps     ,						backbone.channels				):
              self.assertTrue(feature_map.shape[:2]     ,						(batch_size, n_channels)				)
           self.assertIsNone(outputs.hidden_states				)
           self.assertIsNone(outputs.attentions				)

           # Test output_hidden_states=True
           __lowerCamelCase:					Optional[Any]	 =						backbone(**lowercase__     ,						output_hidden_states=lowercase__				)
           self.assertIsNotNone(outputs.hidden_states				)
           self.assertTrue(len(outputs.hidden_states				)     ,						len(backbone.stage_names				)				)
           for hidden_state, n_channels in zip(outputs.hidden_states     ,						backbone.channels				):
              self.assertTrue(hidden_state.shape[:2]     ,						(batch_size, n_channels)				)

           # Test output_attentions=True
           if self.has_attentions:
              __lowerCamelCase:					Optional[int]	 =						backbone(**lowercase__     ,						output_attentions=lowercase__				)
              self.assertIsNotNone(outputs.attentions				)




"""simple docstring"""




from itertools import permutations

def     UpperCamelCase_    (						SCREAMING_SNAKE_CASE_ = 5     ):
					if gon_side < 3 or gon_side > 5:
										raise ValueError('gon_side must be in the range [3, 5]'     )

					# Since it's 16, we know 10 is on the outer ring
					# Put the big numbers at the end so that they are never the first number
					SCREAMING_SNAKE_CASE           =      list(range(gon_side + 1,	0,	-1     )     )
					SCREAMING_SNAKE_CASE           =      list(range(gon_side + 2,	gon_side * 2 + 1     )     )

					for perm in permutations(small_numbers + big_numbers     ):
										SCREAMING_SNAKE_CASE           =      generate_gon_ring(SCREAMING_SNAKE_CASE_,	list(SCREAMING_SNAKE_CASE_     )     )
										if is_magic_gon(SCREAMING_SNAKE_CASE_     ):
															return int(''.join(str(SCREAMING_SNAKE_CASE_     ) for n in numbers     )     )

					SCREAMING_SNAKE_CASE           =      f'''Magic {gon_side}-gon ring is impossible'''
					raise ValueError(SCREAMING_SNAKE_CASE_     )

def     UpperCamelCase_    (						SCREAMING_SNAKE_CASE_,	SCREAMING_SNAKE_CASE_     ):
					SCREAMING_SNAKE_CASE           =      [0] * (gon_side * 3)
					SCREAMING_SNAKE_CASE           =      perm[0:3]
					perm.append(perm[1]     )

					SCREAMING_SNAKE_CASE           =      1 if gon_side < 5 else 2

					for i in range(1,	len(SCREAMING_SNAKE_CASE_     ) // 3 + magic_number     ):
										SCREAMING_SNAKE_CASE           =      perm[2 * i + 1]
										SCREAMING_SNAKE_CASE           =      result[3 * i - 1]
										SCREAMING_SNAKE_CASE           =      perm[2 * i + 2]

					return result

def     UpperCamelCase_    (						SCREAMING_SNAKE_CASE_     ):
					if len(SCREAMING_SNAKE_CASE_     ) % 3 != 0:
										raise ValueError('a gon ring should have a length that is a multiple of 3'     )

					if min(numbers[::3]     ) != numbers[0]:
										return False

					SCREAMING_SNAKE_CASE           =      sum(numbers[:3]     )

					return all(sum(numbers[i : i + 3]     ) == total for i in range(3,	len(SCREAMING_SNAKE_CASE_     ),	3     )     )


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