


"""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 			SCREAMING_SNAKE_CASE_  :




							'''simple docstring'''





							__magic_name__					:     Optional[Any]				  =  ()
							__magic_name__					:     Dict				  =  True




							def        UpperCAmelCase (						self)   ->	List[str]:







								'''simple docstring'''




								snake_case__  :						Union[str, Any]		=      self.config_class

								# test default config
								snake_case__  :						Tuple		=      config_class()
								self.assertIsNotNone(lowerCamelCase__)
								snake_case__  :						str		=      ["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
								snake_case__  :						Optional[int]		=      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
								snake_case__  :						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
								snake_case__  :						Optional[int]		=      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__  :						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(lowerCamelCase__):
									snake_case__  :						str		=      config_class(out_features=["stage1", "stage2"]	,					out_indices=[0, 2])




							def        UpperCAmelCase (						self)   ->	Optional[Any]:







								'''simple docstring'''




								snake_case__,					snake_case__  :						int		=      self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									snake_case__  :						Dict		=      model_class(lowerCamelCase__)
									snake_case__  :						List[str]		=      inspect.signature(model.forward)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									snake_case__  :						Optional[int]		=      [*signature.parameters.keys()]
									snake_case__  :						List[Any]		=      ["pixel_values"]
									self.assertListEqual(arg_names[:1]	,					lowerCamelCase__)




							def        UpperCAmelCase (						self)   ->	Optional[int]:







								'''simple docstring'''




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

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

									snake_case__  :						str		=      copy.deepcopy(lowerCamelCase__)
									snake_case__  :						str		=      None
									snake_case__  :						List[str]		=      model_class(lowerCamelCase__)
									self.assertEqual(len(model.channels)	,					1)
									self.assertListEqual(model.channels	,					[num_features[-1]])

									snake_case__  :						int		=      copy.deepcopy(lowerCamelCase__)
									snake_case__  :						Tuple		=      None
									snake_case__  :						Optional[Any]		=      model_class(lowerCamelCase__)
									self.assertEqual(len(model.channels)	,					1)
									self.assertListEqual(model.channels	,					[num_features[-1]])




							def        UpperCAmelCase (						self)   ->	str:







								'''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__  :						Dict		=      model_class(lowerCamelCase__)
									model.to(lowerCamelCase__)
									model.eval()
									snake_case__  :						Union[str, Any]		=      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
									snake_case__  :						Any		=      copy.deepcopy(lowerCamelCase__)
									snake_case__  :						str		=      None
									snake_case__  :						str		=      model_class(lowerCamelCase__)
									model.to(lowerCamelCase__)
									model.eval()
									snake_case__  :						Dict		=      model(**lowerCamelCase__)

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

									snake_case__  :						Optional[Any]		=      copy.deepcopy(lowerCamelCase__)
									snake_case__  :						Optional[Any]		=      None
									snake_case__  :						int		=      model_class(lowerCamelCase__)
									model.to(lowerCamelCase__)
									model.eval()
									snake_case__  :						Any		=      model(**lowerCamelCase__)

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

									# Check backbone can be initialized with fresh weights
									snake_case__  :						List[Any]		=      copy.deepcopy(lowerCamelCase__)
									snake_case__  :						Optional[Any]		=      False
									snake_case__  :						Optional[Any]		=      model_class(lowerCamelCase__)
									model.to(lowerCamelCase__)
									model.eval()
									snake_case__  :						Dict		=      model(**lowerCamelCase__)




							def        UpperCAmelCase (						self)   ->	Union[str, Any]:







								'''simple docstring'''




								snake_case__,					snake_case__  :						int		=      self.model_tester.prepare_config_and_inputs_for_common()

								for backbone_class in self.all_model_classes:
									snake_case__  :						List[Any]		=      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        UpperCAmelCase (						self)   ->	Optional[int]:







								'''simple docstring'''




								snake_case__,					snake_case__  :						str		=      self.model_tester.prepare_config_and_inputs_for_common()
								snake_case__  :						Any		=      inputs_dict["pixel_values"].shape[0]

								for backbone_class in self.all_model_classes:
									snake_case__  :						str		=      backbone_class(lowerCamelCase__)
									backbone.to(lowerCamelCase__)
									backbone.eval()

									snake_case__  :						Union[str, Any]		=      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
									snake_case__  :						Dict		=      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:
										snake_case__  :						Tuple		=      backbone(**lowerCamelCase__	,					output_attentions=lowerCamelCase__)
										self.assertIsNotNone(outputs.attentions)











import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase__						=		logging.get_logger(__name__)

UpperCamelCase__						=		{}


class 							__SCREAMING_SNAKE_CASE				(						lowerCamelCase    ):
					_lowerCamelCase						    =					"""fsmt_decoder"""

					def __init__(							self					,			__lowercase=0					,			__lowercase=0   ):







						'''simple docstring'''




						super().__init__()
						lowerCamelCase_				:						Tuple				  =				vocab_size
						lowerCamelCase_				:						Union[str, Any]				  =				bos_token_id


class 							__SCREAMING_SNAKE_CASE				(						lowerCamelCase    ):
					_lowerCamelCase						    =					"""fsmt"""
					_lowerCamelCase						    =					{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}

					def __init__(							self					,			__lowercase=["en", "de"]					,			__lowercase=42_024					,			__lowercase=42_024					,			__lowercase="relu"					,			__lowercase=1_024					,			__lowercase=200					,			__lowercase=1_024					,			__lowercase=4_096					,			__lowercase=12					,			__lowercase=16					,			__lowercase=0.0					,			__lowercase=4_096					,			__lowercase=12					,			__lowercase=16					,			__lowercase=0.0					,			__lowercase=0.0					,			__lowercase=0.1					,			__lowercase=0.0					,			__lowercase=0.02					,			__lowercase=2					,			__lowercase=True					,			__lowercase=True					,			__lowercase=False					,			__lowercase=5					,			__lowercase=1.0					,			__lowercase=False					,			__lowercase=True					,			__lowercase=1					,			__lowercase=0					,			__lowercase=2					,			__lowercase=2					,			**__lowercase					,			):







						'''simple docstring'''




						lowerCamelCase_				:						Any				  =				langs
						lowerCamelCase_				:						Union[str, Any]				  =				src_vocab_size
						lowerCamelCase_				:						Tuple				  =				tgt_vocab_size
						lowerCamelCase_				:						List[Any]				  =				d_model  # encoder_embed_dim and decoder_embed_dim

						lowerCamelCase_				:						str				  =				encoder_ffn_dim
						lowerCamelCase_				:						str				  =				encoder_layers
						lowerCamelCase_				:						Dict				  =				encoder_attention_heads
						lowerCamelCase_				:						Any				  =				encoder_layerdrop
						lowerCamelCase_				:						Union[str, Any]				  =				decoder_layerdrop
						lowerCamelCase_				:						Optional[int]				  =				decoder_ffn_dim
						lowerCamelCase_				:						List[str]				  =				decoder_layers
						lowerCamelCase_				:						int				  =				decoder_attention_heads
						lowerCamelCase_				:						List[str]				  =				max_position_embeddings
						lowerCamelCase_				:						int				  =				init_std  # Normal(0, this parameter)
						lowerCamelCase_				:						Optional[Any]				  =				activation_function

						lowerCamelCase_				:						Union[str, Any]				  =				DecoderConfig(vocab_size=__lowercase					,			bos_token_id=__lowercase   )
						if "decoder" in common_kwargs:
							del common_kwargs["decoder"]

						lowerCamelCase_				:						int				  =				scale_embedding  # scale factor will be sqrt(d_model) if True

						# 3 Types of Dropout
						lowerCamelCase_				:						Optional[int]				  =				attention_dropout
						lowerCamelCase_				:						Union[str, Any]				  =				activation_dropout
						lowerCamelCase_				:						Dict				  =				dropout

						lowerCamelCase_				:						Optional[int]				  =				use_cache
						super().__init__(
						    pad_token_id=__lowercase					,			bos_token_id=__lowercase					,			eos_token_id=__lowercase					,			decoder_start_token_id=__lowercase					,			is_encoder_decoder=__lowercase					,			tie_word_embeddings=__lowercase					,			forced_eos_token_id=__lowercase					,			max_length=__lowercase					,			num_beams=__lowercase					,			length_penalty=__lowercase					,			early_stopping=__lowercase					,			**__lowercase					,			)





					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				copy.deepcopy(self.__dict__   )
						lowerCamelCase_				:						Optional[int]				  =				self.decoder.to_dict()
						lowerCamelCase_				:						Dict				  =				self.__class__.model_type
						return output
