

import copy
import inspect

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







@require_torch
class   __lowercase				:
	_UpperCamelCase        =  ()
	_UpperCamelCase        =  True
	def      UpperCamelCase__  (							self ) ->List[str]:



							'''simple docstring'''





							__lowerCAmelCase :						List[Any] = self.config_class

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



							'''simple docstring'''





							__lowerCAmelCase,							__lowerCAmelCase :						Tuple = self.model_tester.prepare_config_and_inputs_for_common()

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



							'''simple docstring'''





							__lowerCAmelCase,							__lowerCAmelCase :						Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													__lowerCAmelCase :						Any = model_class(__SCREAMING_SNAKE_CASE )
													self.assertEqual(len(model.channels )				,							len(config.out_features ) )
													__lowerCAmelCase :						str = model.num_features
													__lowerCAmelCase :						Optional[int] = [config.stage_names.index(__SCREAMING_SNAKE_CASE ) for feat in config.out_features]
													__lowerCAmelCase :						str = [num_features[idx] for idx in out_indices]
													self.assertListEqual(model.channels				,							__SCREAMING_SNAKE_CASE )

													__lowerCAmelCase :						List[Any] = copy.deepcopy(__SCREAMING_SNAKE_CASE )
													__lowerCAmelCase :						int = None
													__lowerCAmelCase :						List[Any] = model_class(__SCREAMING_SNAKE_CASE )
													self.assertEqual(len(model.channels )				,							1 )
													self.assertListEqual(model.channels				,							[num_features[-1]] )

													__lowerCAmelCase :						Tuple = copy.deepcopy(__SCREAMING_SNAKE_CASE )
													__lowerCAmelCase :						Any = None
													__lowerCAmelCase :						Optional[int] = model_class(__SCREAMING_SNAKE_CASE )
													self.assertEqual(len(model.channels )				,							1 )
													self.assertListEqual(model.channels				,							[num_features[-1]] )
	def      UpperCamelCase__  (							self ) ->List[str]:



							'''simple docstring'''





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

							for model_class in self.all_model_classes:
													__lowerCAmelCase :						Any = model_class(__SCREAMING_SNAKE_CASE )
													model.to(__SCREAMING_SNAKE_CASE )
													model.eval()
													__lowerCAmelCase :						Optional[int] = model(**__SCREAMING_SNAKE_CASE )

													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(__SCREAMING_SNAKE_CASE )
													__lowerCAmelCase :						Union[str, Any] = None
													__lowerCAmelCase :						List[str] = model_class(__SCREAMING_SNAKE_CASE )
													model.to(__SCREAMING_SNAKE_CASE )
													model.eval()
													__lowerCAmelCase :						Union[str, Any] = model(**__SCREAMING_SNAKE_CASE )

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

													__lowerCAmelCase :						List[Any] = copy.deepcopy(__SCREAMING_SNAKE_CASE )
													__lowerCAmelCase :						List[Any] = None
													__lowerCAmelCase :						Optional[Any] = model_class(__SCREAMING_SNAKE_CASE )
													model.to(__SCREAMING_SNAKE_CASE )
													model.eval()
													__lowerCAmelCase :						Any = model(**__SCREAMING_SNAKE_CASE )

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

													# Check backbone can be initialized with fresh weights
													__lowerCAmelCase :						Tuple = copy.deepcopy(__SCREAMING_SNAKE_CASE )
													__lowerCAmelCase :						str = False
													__lowerCAmelCase :						Tuple = model_class(__SCREAMING_SNAKE_CASE )
													model.to(__SCREAMING_SNAKE_CASE )
													model.eval()
													__lowerCAmelCase :						List[Any] = model(**__SCREAMING_SNAKE_CASE )
	def      UpperCamelCase__  (							self ) ->Optional[int]:



							'''simple docstring'''





							__lowerCAmelCase,							__lowerCAmelCase :						Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common()

							for backbone_class in self.all_model_classes:
													__lowerCAmelCase :						Tuple = backbone_class(__SCREAMING_SNAKE_CASE )

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

													self.assertIsInstance(backbone.backbone_type				,							__SCREAMING_SNAKE_CASE )
													# 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 ) ->str:



							'''simple docstring'''





							__lowerCAmelCase,							__lowerCAmelCase :						Dict = 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 :						Tuple = backbone_class(__SCREAMING_SNAKE_CASE )
													backbone.to(__SCREAMING_SNAKE_CASE )
													backbone.eval()

													__lowerCAmelCase :						List[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
													__lowerCAmelCase :						Union[str, 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 ) )
													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 :						Any = backbone(**__SCREAMING_SNAKE_CASE				,							output_attentions=__SCREAMING_SNAKE_CASE )
																			self.assertIsNotNone(outputs.attentions )





def 		_lowercase			(					lowercase__       ,     lowercase__						):
      if len(str(lowercase__						)						) == 1 or len(str(lowercase__						)						) == 1:
            return a * b

      __lowerCAmelCase :						Any = max(len(str(lowercase__						)						)       ,     len(str(lowercase__						)						)						)
      __lowerCAmelCase :						Optional[int] = ma // 2

      __lowerCAmelCase,							__lowerCAmelCase :						Tuple = divmod(lowercase__       ,     1_0**ma						)
      __lowerCAmelCase,							__lowerCAmelCase :						Any = divmod(lowercase__       ,     1_0**ma						)

      __lowerCAmelCase :						str = karatsuba(lowercase__       ,     lowercase__						)
      __lowerCAmelCase :						Optional[int] = karatsuba((aa + aa)       ,     (ba + ba)						)
      __lowerCAmelCase :						List[Any] = karatsuba(lowercase__       ,     lowercase__						)

      return (z * 1_0 ** (2 * ma)) + ((y - z - x) * 1_0 ** (ma)) + (x)







def 		_lowercase			(					):
      print(karatsuba(1_5_4_6_3       ,     2_3_4_8_9						)						)


if __name__ == "__main__":
 main()


