code: import copy
  import inspect
  
  from transformers.testing_utils import require_torch, torch_device
  from transformers.utils.backbone_utils import BackboneType
  
  
  
  
  @require_torch
  class      lowercase_						:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  	UpperCAmelCase_						:      Optional[int]     =       ()
  	UpperCAmelCase_						:      Optional[int]     =       True
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Dict:
  								lowerCAmelCase				=	self.config_class
  
  								# test default config
  								lowerCAmelCase				=	config_class()
  								self.assertIsNotNone(UpperCamelCase__       )
  								lowerCAmelCase				=	['''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				=	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				=	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				=	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				=	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				=	config_class(out_features=['''stage1''', '''stage2''']	,    out_indices=[0, 2]       )
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Tuple:
  								lowerCAmelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															lowerCAmelCase				=	inspect.signature(model.forward       )
  															# signature.parameters is an OrderedDict => so arg_names order is deterministic
  															lowerCAmelCase				=	[*signature.parameters.keys()]
  															lowerCAmelCase				=	['''pixel_values''']
  															self.assertListEqual(arg_names[:1]	,    UpperCamelCase__       )
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Optional[int]:
  								lowerCAmelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															self.assertEqual(len(model.channels       )	,    len(config.out_features       )       )
  															lowerCAmelCase				=	model.num_features
  															lowerCAmelCase				=	[config.stage_names.index(UpperCamelCase__       ) for feat in config.out_features]
  															lowerCAmelCase				=	[num_features[idx] for idx in out_indices]
  															self.assertListEqual(model.channels	,    UpperCamelCase__       )
  
  															lowerCAmelCase				=	copy.deepcopy(UpperCamelCase__       )
  															lowerCAmelCase				=	None
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															self.assertEqual(len(model.channels       )	,    1       )
  															self.assertListEqual(model.channels	,    [num_features[-1]]       )
  
  															lowerCAmelCase				=	copy.deepcopy(UpperCamelCase__       )
  															lowerCAmelCase				=	None
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															self.assertEqual(len(model.channels       )	,    1       )
  															self.assertListEqual(model.channels	,    [num_features[-1]]       )
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->List[Any]:
  								lowerCAmelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															model.to(UpperCamelCase__       )
  															model.eval()
  															lowerCAmelCase				=	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				=	copy.deepcopy(UpperCamelCase__       )
  															lowerCAmelCase				=	None
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															model.to(UpperCamelCase__       )
  															model.eval()
  															lowerCAmelCase				=	model(**UpperCamelCase__       )
  
  															self.assertEqual(len(result.feature_maps       )	,    1       )
  															self.assertEqual(len(model.channels       )	,    1       )
  
  															lowerCAmelCase				=	copy.deepcopy(UpperCamelCase__       )
  															lowerCAmelCase				=	None
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															model.to(UpperCamelCase__       )
  															model.eval()
  															lowerCAmelCase				=	model(**UpperCamelCase__       )
  
  															self.assertEqual(len(result.feature_maps       )	,    1       )
  															self.assertEqual(len(model.channels       )	,    1       )
  
  															# Check backbone can be initialized with fresh weights
  															lowerCAmelCase				=	copy.deepcopy(UpperCamelCase__       )
  															lowerCAmelCase				=	False
  															lowerCAmelCase				=	model_class(UpperCamelCase__       )
  															model.to(UpperCamelCase__       )
  															model.eval()
  															lowerCAmelCase				=	model(**UpperCamelCase__       )
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Optional[int]:
  								lowerCAmelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  								for backbone_class in self.all_model_classes:
  															lowerCAmelCase				=	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     SCREAMING_SNAKE_CASE_       (							self       )		->str:
  								lowerCAmelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
  								lowerCAmelCase				=	inputs_dict['''pixel_values'''].shape[0]
  
  								for backbone_class in self.all_model_classes:
  															lowerCAmelCase				=	backbone_class(UpperCamelCase__       )
  															backbone.to(UpperCamelCase__       )
  															backbone.eval()
  
  															lowerCAmelCase				=	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				=	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				=	backbone(**UpperCamelCase__	,    output_attentions=UpperCamelCase__       )
  																						self.assertIsNotNone(outputs.attentions       )
  
  
  
  
style_context: import math
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__							)  ->			float:
  							lowerCAmelCase				=	math.log(2     ,						1_0							) * number
  							lowerCAmelCase				=	round((log_number - int(snake_case__							))     ,						1_5							)
  
  							return difference
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__ = 6_7_8_9_1_0							)  ->			int:
  							lowerCAmelCase				=	9_0
  							lowerCAmelCase				=	0
  
  							lowerCAmelCase				=	math.log(1.23     ,						1_0							)
  							lowerCAmelCase				=	math.log(1.24     ,						1_0							)
  							lowerCAmelCase				=	0
  
  							while position < number:
  														lowerCAmelCase				=	log_difference(snake_case__							)
  
  														if difference >= upper_limit:
  																					power_iterator += 9_3
  
  														elif difference < lower_limit:
  																					power_iterator += 1_9_6
  
  														else:
  																					lowerCAmelCase				=	power_iterator
  																					power_iterator += 1_9_6
  																					position += 1
  
  							return previous_power
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  	print(f'{solution() = }')
  
  
  
  