


"""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"""
							SCREAMING_SNAKE_CASE              =   ()
							SCREAMING_SNAKE_CASE              =   True






							def        lowerCAmelCase  (    self			:  Dict					):
													UpperCAmelCase__												=     self.config_class

													# test default config
													UpperCAmelCase__												=     config_class()
													self.assertIsNotNone(lowerCamelCase_					)
													UpperCAmelCase__												=     ['''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
													UpperCAmelCase__												=     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
													UpperCAmelCase__												=     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
													UpperCAmelCase__												=     config_class(out_features=['''stage1''', '''stage3''']					)
													self.assertEqual(config.out_features		,			['''stage1''', '''stage3''']					)
													self.assertEqual(config.out_indices		,			[1, 3]					)

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






							def        lowerCAmelCase  (    self			:  Tuple					):
													UpperCAmelCase__						,					UpperCAmelCase__												=     self.model_tester.prepare_config_and_inputs_for_common()

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






							def        lowerCAmelCase  (    self			:  str					):
													UpperCAmelCase__						,					UpperCAmelCase__												=     self.model_tester.prepare_config_and_inputs_for_common()

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

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

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






							def        lowerCAmelCase  (    self			:  Optional[int]					):
													UpperCAmelCase__						,					UpperCAmelCase__												=     self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			UpperCAmelCase__												=     model_class(lowerCamelCase_					)
																			model.to(lowerCamelCase_					)
																			model.eval()
																			UpperCAmelCase__												=     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
																			UpperCAmelCase__												=     copy.deepcopy(lowerCamelCase_					)
																			UpperCAmelCase__												=     None
																			UpperCAmelCase__												=     model_class(lowerCamelCase_					)
																			model.to(lowerCamelCase_					)
																			model.eval()
																			UpperCAmelCase__												=     model(**lowerCamelCase_					)

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

																			UpperCAmelCase__												=     copy.deepcopy(lowerCamelCase_					)
																			UpperCAmelCase__												=     None
																			UpperCAmelCase__												=     model_class(lowerCamelCase_					)
																			model.to(lowerCamelCase_					)
																			model.eval()
																			UpperCAmelCase__												=     model(**lowerCamelCase_					)

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

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






							def        lowerCAmelCase  (    self			:  Any					):
													UpperCAmelCase__						,					UpperCAmelCase__												=     self.model_tester.prepare_config_and_inputs_for_common()

													for backbone_class in self.all_model_classes:
																			UpperCAmelCase__												=     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        lowerCAmelCase  (    self			:  Dict					):
													UpperCAmelCase__						,					UpperCAmelCase__												=     self.model_tester.prepare_config_and_inputs_for_common()
													UpperCAmelCase__												=     inputs_dict['''pixel_values'''].shape[0]

													for backbone_class in self.all_model_classes:
																			UpperCAmelCase__												=     backbone_class(lowerCamelCase_					)
																			backbone.to(lowerCamelCase_					)
																			backbone.eval()

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



"""simple docstring"""







from __future__ import annotations






def        a__			(							_UpperCamelCase			):





						"""simple docstring"""

						UpperCAmelCase__												=     sorted(_UpperCamelCase			)
						UpperCAmelCase__												=     len(_UpperCamelCase			)
						UpperCAmelCase__												=     length >> 1
						return (
						    (sorted_list[mid_index] + sorted_list[mid_index - 1]) / 2
						    if length % 2 == 0
						    else sorted_list[mid_index]
						)






def        a__			(							):





						"""simple docstring"""

						import doctest

						doctest.testmod()


if __name__ == "__main__":
						main()