






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

					'''simple docstring'''





					lowercase_						:							Dict			=     ()
					lowercase_						:							Any			=     True
					def 					UpperCAmelCase__   (       self       :  int      )  ->					Optional[int]:
											lowerCAmelCase      :Optional[int]				  = self.config_class

											# test default config
											lowerCAmelCase      :Dict				  = config_class()
											self.assertIsNotNone(UpperCAmelCase      )
											lowerCAmelCase      :List[str]				  = ['stem'] + [f"""stage{idx}""" for idx in range(1    ,   len(config.depths      ) + 1      )]
											self.assertEqual(config.stage_names    ,   UpperCAmelCase      )
											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      :Dict				  = config_class(out_features=UpperCAmelCase    ,   out_indices=UpperCAmelCase      )
											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      :str				  = 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      :Dict				  = 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      :Dict				  = 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(UpperCAmelCase      ):
																	lowerCAmelCase      :Tuple				  = config_class(out_features=['stage1', 'stage2']    ,   out_indices=[0, 2]      )
					def 					UpperCAmelCase__   (       self       :  Any      )  ->					int:
											lowerCAmelCase      :Dict				  = self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowerCAmelCase      :Tuple				  = model_class(UpperCAmelCase      )
																	lowerCAmelCase      :str				  = inspect.signature(model.forward      )
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	lowerCAmelCase      :Dict				  = [*signature.parameters.keys()]
																	lowerCAmelCase      :Union[str, Any]				  = ['pixel_values']
																	self.assertListEqual(arg_names[:1]    ,   UpperCAmelCase      )
					def 					UpperCAmelCase__   (       self       :  Optional[Any]      )  ->					Optional[Any]:
											lowerCAmelCase      :Tuple				  = self.model_tester.prepare_config_and_inputs_for_common()

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

																	lowerCAmelCase      :Any				  = copy.deepcopy(UpperCAmelCase      )
																	lowerCAmelCase      :Optional[Any]				  = None
																	lowerCAmelCase      :Optional[int]				  = model_class(UpperCAmelCase      )
																	self.assertEqual(len(model.channels      )    ,   1      )
																	self.assertListEqual(model.channels    ,   [num_features[-1]]      )

																	lowerCAmelCase      :Dict				  = copy.deepcopy(UpperCAmelCase      )
																	lowerCAmelCase      :Optional[int]				  = None
																	lowerCAmelCase      :int				  = model_class(UpperCAmelCase      )
																	self.assertEqual(len(model.channels      )    ,   1      )
																	self.assertListEqual(model.channels    ,   [num_features[-1]]      )
					def 					UpperCAmelCase__   (       self       :  List[str]      )  ->					List[Any]:
											lowerCAmelCase      :List[str]				  = self.model_tester.prepare_config_and_inputs_for_common()

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

																	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(UpperCAmelCase      )
																	lowerCAmelCase      :Any				  = None
																	lowerCAmelCase      :Optional[int]				  = model_class(UpperCAmelCase      )
																	model.to(UpperCAmelCase      )
																	model.eval()
																	lowerCAmelCase      :Any				  = model(**UpperCAmelCase      )

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

																	lowerCAmelCase      :Any				  = copy.deepcopy(UpperCAmelCase      )
																	lowerCAmelCase      :Dict				  = None
																	lowerCAmelCase      :int				  = model_class(UpperCAmelCase      )
																	model.to(UpperCAmelCase      )
																	model.eval()
																	lowerCAmelCase      :int				  = model(**UpperCAmelCase      )

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

																	# Check backbone can be initialized with fresh weights
																	lowerCAmelCase      :Union[str, Any]				  = copy.deepcopy(UpperCAmelCase      )
																	lowerCAmelCase      :Tuple				  = False
																	lowerCAmelCase      :Any				  = model_class(UpperCAmelCase      )
																	model.to(UpperCAmelCase      )
																	model.eval()
																	lowerCAmelCase      :Any				  = model(**UpperCAmelCase      )
					def 					UpperCAmelCase__   (       self       :  Optional[int]      )  ->					Union[str, Any]:
											lowerCAmelCase      :List[Any]				  = self.model_tester.prepare_config_and_inputs_for_common()

											for backbone_class in self.all_model_classes:
																	lowerCAmelCase      :int				  = backbone_class(UpperCAmelCase      )

																	self.assertTrue(hasattr(UpperCAmelCase    ,   'backbone_type'      )      )
																	self.assertTrue(hasattr(UpperCAmelCase    ,   'stage_names'      )      )
																	self.assertTrue(hasattr(UpperCAmelCase    ,   'num_features'      )      )
																	self.assertTrue(hasattr(UpperCAmelCase    ,   'out_indices'      )      )
																	self.assertTrue(hasattr(UpperCAmelCase    ,   'out_features'      )      )
																	self.assertTrue(hasattr(UpperCAmelCase    ,   'out_feature_channels'      )      )
																	self.assertTrue(hasattr(UpperCAmelCase    ,   'channels'      )      )

																	self.assertIsInstance(backbone.backbone_type    ,   UpperCAmelCase      )
																	# 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       :  Dict      )  ->					str:
											lowerCAmelCase      :Optional[int]				  = self.model_tester.prepare_config_and_inputs_for_common()
											lowerCAmelCase      :Any				  = inputs_dict['pixel_values'].shape[0]

											for backbone_class in self.all_model_classes:
																	lowerCAmelCase      :List[Any]				  = backbone_class(UpperCAmelCase      )
																	backbone.to(UpperCAmelCase      )
																	backbone.eval()

																	lowerCAmelCase      :Union[str, Any]				  = backbone(**UpperCAmelCase      )

																	# Test default outputs and verify feature maps
																	self.assertIsInstance(outputs.feature_maps    ,   UpperCAmelCase      )
																	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      :List[str]				  = backbone(**UpperCAmelCase    ,   output_hidden_states=UpperCAmelCase      )
																	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      :Union[str, Any]				  = backbone(**UpperCAmelCase    ,   output_attentions=UpperCAmelCase      )
																							self.assertIsNotNone(outputs.attentions      )







"""simple docstring"""


import safs




class 	__UpperCamelCase    (    safs.SaFileSystem	):
					pass