code: 
  '''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   snake_case__					:
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	()
  		lowerCamelCase           =	True
  
  
  
  		def 			lowerCAmelCase							(			self							: Union[str, Any]			)	-> Dict:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Union[str, Any]     =	self.config_class
  
  				# test default config
  				snake_case     :					Optional[int]     =	config_class()
  				self.assertIsNotNone(UpperCamelCase__			)
  				snake_case     :					Union[str, Any]     =	['''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
  				snake_case     :					Optional[int]     =	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
  				snake_case     :					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
  				snake_case     :					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
  				snake_case     :					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(UpperCamelCase__			):
  						snake_case     :					Tuple     =	config_class(out_features=['''stage1''', '''stage2''']     ,  out_indices=[0, 2]			)
  
  
  
  		def 			lowerCAmelCase							(			self							: str			)	-> Tuple:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case ,snake_case     :					Optional[Any]     =	self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  						snake_case     :					Any     =	model_class(UpperCamelCase__			)
  						snake_case     :					Union[str, Any]     =	inspect.signature(model.forward			)
  						# signature.parameters is an OrderedDict => so arg_names order is deterministic
  						snake_case     :					int     =	[*signature.parameters.keys()]
  						snake_case     :					List[Any]     =	['''pixel_values''']
  						self.assertListEqual(arg_names[:1]     ,  UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Optional[int]			)	-> Optional[int]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case ,snake_case     :					Any     =	self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  						snake_case     :					int     =	model_class(UpperCamelCase__			)
  						self.assertEqual(len(model.channels			)     ,  len(config.out_features			)			)
  						snake_case     :					Any     =	model.num_features
  						snake_case     :					Optional[Any]     =	[config.stage_names.index(UpperCamelCase__			) for feat in config.out_features]
  						snake_case     :					Dict     =	[num_features[idx] for idx in out_indices]
  						self.assertListEqual(model.channels     ,  UpperCamelCase__			)
  
  						snake_case     :					Optional[Any]     =	copy.deepcopy(UpperCamelCase__			)
  						snake_case     :					Tuple     =	None
  						snake_case     :					Optional[int]     =	model_class(UpperCamelCase__			)
  						self.assertEqual(len(model.channels			)     ,  1			)
  						self.assertListEqual(model.channels     ,  [num_features[-1]]			)
  
  						snake_case     :					Optional[int]     =	copy.deepcopy(UpperCamelCase__			)
  						snake_case     :					int     =	None
  						snake_case     :					Union[str, Any]     =	model_class(UpperCamelCase__			)
  						self.assertEqual(len(model.channels			)     ,  1			)
  						self.assertListEqual(model.channels     ,  [num_features[-1]]			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Dict			)	-> List[Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case ,snake_case     :					Tuple     =	self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  						snake_case     :					Any     =	model_class(UpperCamelCase__			)
  						model.to(UpperCamelCase__			)
  						model.eval()
  						snake_case     :					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
  						snake_case     :					Union[str, Any]     =	copy.deepcopy(UpperCamelCase__			)
  						snake_case     :					Dict     =	None
  						snake_case     :					Any     =	model_class(UpperCamelCase__			)
  						model.to(UpperCamelCase__			)
  						model.eval()
  						snake_case     :					Any     =	model(**UpperCamelCase__			)
  
  						self.assertEqual(len(result.feature_maps			)     ,  1			)
  						self.assertEqual(len(model.channels			)     ,  1			)
  
  						snake_case     :					Union[str, Any]     =	copy.deepcopy(UpperCamelCase__			)
  						snake_case     :					str     =	None
  						snake_case     :					List[Any]     =	model_class(UpperCamelCase__			)
  						model.to(UpperCamelCase__			)
  						model.eval()
  						snake_case     :					List[str]     =	model(**UpperCamelCase__			)
  
  						self.assertEqual(len(result.feature_maps			)     ,  1			)
  						self.assertEqual(len(model.channels			)     ,  1			)
  
  						# Check backbone can be initialized with fresh weights
  						snake_case     :					Optional[Any]     =	copy.deepcopy(UpperCamelCase__			)
  						snake_case     :					int     =	False
  						snake_case     :					List[str]     =	model_class(UpperCamelCase__			)
  						model.to(UpperCamelCase__			)
  						model.eval()
  						snake_case     :					Optional[Any]     =	model(**UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Union[str, Any]			)	-> Optional[int]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case ,snake_case     :					Optional[Any]     =	self.model_tester.prepare_config_and_inputs_for_common()
  
  				for backbone_class in self.all_model_classes:
  						snake_case     :					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 			lowerCAmelCase							(			self							: Dict			)	-> str:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case ,snake_case     :					Any     =	self.model_tester.prepare_config_and_inputs_for_common()
  				snake_case     :					Union[str, Any]     =	inputs_dict['''pixel_values'''].shape[0]
  
  				for backbone_class in self.all_model_classes:
  						snake_case     :					Optional[int]     =	backbone_class(UpperCamelCase__			)
  						backbone.to(UpperCamelCase__			)
  						backbone.eval()
  
  						snake_case     :					List[str]     =	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
  						snake_case     :					Any     =	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:
  								snake_case     :					int     =	backbone(**UpperCamelCase__     ,  output_attentions=UpperCamelCase__			)
  								self.assertIsNotNone(outputs.attentions			)
  
  
  
style_context: 
  '''simple docstring'''
  import numpy as np
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       Optional[Any]:
  
  
  		'''simple docstring'''
  
  
  		snake_case ,snake_case     :					str     =	a.shape
  		snake_case     :					Union[str, Any]     =	min(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					List[Any]     =	np.eye(SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Union[str, Any]     =	a.copy()
  
  		for k in range(t - 1 ):
  				# select a column of modified matrix A':
  				snake_case     :					Union[str, Any]     =	r[k:, [k]]
  				# construct first basis vector
  				snake_case     :					str     =	np.zeros_like(SCREAMING_SNAKE_CASE__ )
  				snake_case     :					List[str]     =	1.0
  				# determine scaling factor
  				snake_case     :					int     =	np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  				# construct vector v for Householder reflection
  				snake_case     :					Optional[int]     =	x + np.sign(x[0] ) * alpha * ea
  				v /= np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  
  				# construct the Householder matrix
  				snake_case     :					Tuple     =	np.eye(m - k ) - 2.0 * v @ v.T
  				# pad with ones and zeros as necessary
  				snake_case     :					int     =	np.block([[np.eye(SCREAMING_SNAKE_CASE__ ), np.zeros((k, m - k) )], [np.zeros((m - k, k) ), q_k]] )
  
  				snake_case     :					int     =	q @ q_k.T
  				snake_case     :					Dict     =	q_k @ r
  
  		return q, r
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
  
  