


"""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       __a	:
				lowerCamelCase    :					Any 					=()
				lowerCamelCase    :					Union[str, Any] 					=True







				def     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					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     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					lowerCAmelCase_       ,  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     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					lowerCAmelCase_       ,  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     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					lowerCAmelCase_       ,  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     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					lowerCAmelCase_       ,  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     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					lowerCAmelCase_       ,  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      )



"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase_							 =       {
    'configuration_prophetnet': ['PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ProphetNetConfig'],
    'tokenization_prophetnet': ['ProphetNetTokenizer'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase_							 =       [
		    'PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'ProphetNetDecoder',
		    'ProphetNetEncoder',
		    'ProphetNetForCausalLM',
		    'ProphetNetForConditionalGeneration',
		    'ProphetNetModel',
		    'ProphetNetPreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_prophetnet import PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ProphetNetConfig
		from .tokenization_prophetnet import ProphetNetTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_prophetnet import (
				    PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ProphetNetDecoder,
				    ProphetNetEncoder,
				    ProphetNetForCausalLM,
				    ProphetNetForConditionalGeneration,
				    ProphetNetModel,
				    ProphetNetPreTrainedModel,
				)

else:
		import sys

		lowercase_							 =       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)