


'''simple docstring'''
import copy
import inspect

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






@require_torch
class 				__lowerCAmelCase      :

						"""simple docstring"""






						_UpperCAmelCase		:					Optional[int]      	=()
						_UpperCAmelCase		:					List[str]      	=True






						def 							_UpperCAmelCase					(     self       :			Dict  ):
													A_ 						=		self.config_class

													# test default config
													A_ 						=		config_class()
													self.assertIsNotNone(lowerCAmelCase  )
													A_ 						=		["stem"] + [F"stage{idx}" for idx in range(1   ,     len(config.depths  ) + 1  )]
													self.assertEqual(config.stage_names   ,     lowerCAmelCase  )
													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
													A_ 						=		config_class(out_features=lowerCAmelCase   ,     out_indices=lowerCAmelCase  )
													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
													A_ 						=		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
													A_ 						=		config_class(out_features=["stage1", "stage3"]  )
													self.assertEqual(config.out_features   ,     ["stage1", "stage3"]  )
													self.assertEqual(config.out_indices   ,     [1, 3]  )

													# Only out_indices set
													A_ 						=		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(lowerCAmelCase  ):
																				A_ 						=		config_class(out_features=["stage1", "stage2"]   ,     out_indices=[0, 2]  )






						def 							_UpperCAmelCase					(     self       :			Tuple  ):
													A_						,				A_ 						=		self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A_ 						=		model_class(lowerCAmelCase  )
																				A_ 						=		inspect.signature(model.forward  )
																				# signature.parameters is an OrderedDict => so arg_names order is deterministic
																				A_ 						=		[*signature.parameters.keys()]
																				A_ 						=		["pixel_values"]
																				self.assertListEqual(arg_names[:1]   ,     lowerCAmelCase  )






						def 							_UpperCAmelCase					(     self       :			List[Any]  ):
													A_						,				A_ 						=		self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A_ 						=		model_class(lowerCAmelCase  )
																				self.assertEqual(len(model.channels  )   ,     len(config.out_features  )  )
																				A_ 						=		model.num_features
																				A_ 						=		[config.stage_names.index(lowerCAmelCase  ) for feat in config.out_features]
																				A_ 						=		[num_features[idx] for idx in out_indices]
																				self.assertListEqual(model.channels   ,     lowerCAmelCase  )

																				A_ 						=		copy.deepcopy(lowerCAmelCase  )
																				A_ 						=		None
																				A_ 						=		model_class(lowerCAmelCase  )
																				self.assertEqual(len(model.channels  )   ,     1  )
																				self.assertListEqual(model.channels   ,     [num_features[-1]]  )

																				A_ 						=		copy.deepcopy(lowerCAmelCase  )
																				A_ 						=		None
																				A_ 						=		model_class(lowerCAmelCase  )
																				self.assertEqual(len(model.channels  )   ,     1  )
																				self.assertListEqual(model.channels   ,     [num_features[-1]]  )






						def 							_UpperCAmelCase					(     self       :			Tuple  ):
													A_						,				A_ 						=		self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A_ 						=		model_class(lowerCAmelCase  )
																				model.to(lowerCAmelCase  )
																				model.eval()
																				A_ 						=		model(**lowerCAmelCase  )

																				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
																				A_ 						=		copy.deepcopy(lowerCAmelCase  )
																				A_ 						=		None
																				A_ 						=		model_class(lowerCAmelCase  )
																				model.to(lowerCAmelCase  )
																				model.eval()
																				A_ 						=		model(**lowerCAmelCase  )

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

																				A_ 						=		copy.deepcopy(lowerCAmelCase  )
																				A_ 						=		None
																				A_ 						=		model_class(lowerCAmelCase  )
																				model.to(lowerCAmelCase  )
																				model.eval()
																				A_ 						=		model(**lowerCAmelCase  )

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

																				# Check backbone can be initialized with fresh weights
																				A_ 						=		copy.deepcopy(lowerCAmelCase  )
																				A_ 						=		False
																				A_ 						=		model_class(lowerCAmelCase  )
																				model.to(lowerCAmelCase  )
																				model.eval()
																				A_ 						=		model(**lowerCAmelCase  )






						def 							_UpperCAmelCase					(     self       :			int  ):
													A_						,				A_ 						=		self.model_tester.prepare_config_and_inputs_for_common()

													for backbone_class in self.all_model_classes:
																				A_ 						=		backbone_class(lowerCAmelCase  )

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

																				self.assertIsInstance(backbone.backbone_type   ,     lowerCAmelCase  )
																				# 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 							_UpperCAmelCase					(     self       :			Optional[int]  ):
													A_						,				A_ 						=		self.model_tester.prepare_config_and_inputs_for_common()
													A_ 						=		inputs_dict["pixel_values"].shape[0]

													for backbone_class in self.all_model_classes:
																				A_ 						=		backbone_class(lowerCAmelCase  )
																				backbone.to(lowerCAmelCase  )
																				backbone.eval()

																				A_ 						=		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
																				A_ 						=		backbone(**lowerCAmelCase   ,     output_hidden_states=lowerCAmelCase  )
																				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:
																											A_ 						=		backbone(**lowerCAmelCase   ,     output_attentions=lowerCAmelCase  )
																											self.assertIsNotNone(outputs.attentions  )









'''simple docstring'''
def 			a_							(  UpperCamelCase_   ):
							if not isinstance(UpperCamelCase_	,     UpperCamelCase_   ):
														A_ 						=		f"Input value of [number={number}] must be an integer"
														raise TypeError(UpperCamelCase_   )
							if number < 0 or number % 2 == 1:
														return False
							A_ 						=		int(number**0.5   )
							return number == number_sqrt * (number_sqrt + 1)


if __name__ == "__main__":
							import doctest

							doctest.testmod()





