


import copy
import inspect

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



@require_torch
class 							A					:
					'''simple docstring'''






					A__    =				()
					A__    =				True

					def 						lowerCamelCase__  (self					:		Dict	)		->     int:




							"""simple docstring"""


							lowercase__      =	self.config_class

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

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

					def 						lowerCamelCase__  (self					:		Optional[Any]	)		->     Tuple:




							"""simple docstring"""


							lowercase__    ,			lowercase__      =	self.model_tester.prepare_config_and_inputs_for_common()

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

					def 						lowerCamelCase__  (self					:		List[Any]	)		->     int:




							"""simple docstring"""


							lowercase__    ,			lowercase__      =	self.model_tester.prepare_config_and_inputs_for_common()

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

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

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

					def 						lowerCamelCase__  (self					:		Any	)		->     Dict:




							"""simple docstring"""


							lowercase__    ,			lowercase__      =	self.model_tester.prepare_config_and_inputs_for_common()

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

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

									lowercase__      =	copy.deepcopy(_UpperCAmelCase	)
									lowercase__      =	None
									lowercase__      =	model_class(_UpperCAmelCase	)
									model.to(_UpperCAmelCase	)
									model.eval()
									lowercase__      =	model(**_UpperCAmelCase	)

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

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

					def 						lowerCamelCase__  (self					:		List[str]	)		->     Optional[Any]:




							"""simple docstring"""


							lowercase__    ,			lowercase__      =	self.model_tester.prepare_config_and_inputs_for_common()

							for backbone_class in self.all_model_classes:
									lowercase__      =	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					:		List[str]	)		->     Any:




							"""simple docstring"""


							lowercase__    ,			lowercase__      =	self.model_tester.prepare_config_and_inputs_for_common()
							lowercase__      =	inputs_dict["""pixel_values"""].shape[0]

							for backbone_class in self.all_model_classes:
									lowercase__      =	backbone_class(_UpperCAmelCase	)
									backbone.to(_UpperCAmelCase	)
									backbone.eval()

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





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


A :	str												=     {
    'configuration_nystromformer': ['NYSTROMFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'NystromformerConfig'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A :	Optional[int]												=     [
	    'NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'NystromformerForMaskedLM',
	    'NystromformerForMultipleChoice',
	    'NystromformerForQuestionAnswering',
	    'NystromformerForSequenceClassification',
	    'NystromformerForTokenClassification',
	    'NystromformerLayer',
	    'NystromformerModel',
	    'NystromformerPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_nystromformer import NYSTROMFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, NystromformerConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_nystromformer import (
		    NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    NystromformerForMaskedLM,
		    NystromformerForMultipleChoice,
		    NystromformerForQuestionAnswering,
		    NystromformerForSequenceClassification,
		    NystromformerForTokenClassification,
		    NystromformerLayer,
		    NystromformerModel,
		    NystromformerPreTrainedModel,
		)


else:
	import sys

	A :	Optional[int]												=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

