






"""simple docstring"""







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


_lowerCAmelCase            =	logging.get_logger(__name__)

_lowerCAmelCase            =	{
    'SenseTime/deformable-detr': 'https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json',
    # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr
}


class      UpperCamelCase		(__snake_case     ):
						_SCREAMING_SNAKE_CASE  : str												=		"""deformable_detr"""
						_SCREAMING_SNAKE_CASE  : Tuple												=		{
						    """hidden_size""": """d_model""",
						    """num_attention_heads""": """encoder_attention_heads""",
						}






						def __init__(		self  :Any			, __magic_name__  :List[Any]=True			, __magic_name__  :str=None			, __magic_name__  :Union[str, Any]=3			, __magic_name__  :Any=300			, __magic_name__  :Optional[Any]=1_024			, __magic_name__  :Union[str, Any]=6			, __magic_name__  :Tuple=1_024			, __magic_name__  :Dict=8			, __magic_name__  :Optional[Any]=6			, __magic_name__  :Union[str, Any]=1_024			, __magic_name__  :Any=8			, __magic_name__  :str=0.0			, __magic_name__  :Optional[int]=True			, __magic_name__  :int="relu"			, __magic_name__  :Optional[int]=256			, __magic_name__  :Tuple=0.1			, __magic_name__  :Dict=0.0			, __magic_name__  :Optional[int]=0.0			, __magic_name__  :Optional[int]=0.02			, __magic_name__  :str=1.0			, __magic_name__  :str=True			, __magic_name__  :Any=False			, __magic_name__  :Union[str, Any]="sine"			, __magic_name__  :Dict="resnet50"			, __magic_name__  :Dict=True			, __magic_name__  :Any=False			, __magic_name__  :List[str]=4			, __magic_name__  :Tuple=4			, __magic_name__  :Tuple=4			, __magic_name__  :List[str]=False			, __magic_name__  :Any=300			, __magic_name__  :int=False			, __magic_name__  :Any=1			, __magic_name__  :Tuple=5			, __magic_name__  :int=2			, __magic_name__  :Dict=1			, __magic_name__  :Any=1			, __magic_name__  :List[Any]=5			, __magic_name__  :Union[str, Any]=2			, __magic_name__  :List[str]=0.1			, __magic_name__  :List[Any]=0.25			, __magic_name__  :str=False			, **__magic_name__  :str			, )      ->Any:
										if backbone_config is not None and use_timm_backbone:
														raise ValueError("""You can't specify both `backbone_config` and `use_timm_backbone`."""				)

										if not use_timm_backbone:
														if backbone_config is None:
																		logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""				)
																		lowercase    :      int       = CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""]				)
														elif isinstance(__magic_name__			, __magic_name__				):
																		lowercase    :      str       = backbone_config.get("""model_type"""				)
																		lowercase    :      List[str]       = CONFIG_MAPPING[backbone_model_type]
																		lowercase    :      Any       = config_class.from_dict(__magic_name__				)
										lowercase    :      Dict       = use_timm_backbone
										lowercase    :      str       = backbone_config
										lowercase    :      int       = num_channels
										lowercase    :      List[Any]       = num_queries
										lowercase    :      Optional[int]       = max_position_embeddings
										lowercase    :      Tuple       = d_model
										lowercase    :      Union[str, Any]       = encoder_ffn_dim
										lowercase    :      Any       = encoder_layers
										lowercase    :      Any       = encoder_attention_heads
										lowercase    :      Dict       = decoder_ffn_dim
										lowercase    :      Dict       = decoder_layers
										lowercase    :      Optional[Any]       = decoder_attention_heads
										lowercase    :      Any       = dropout
										lowercase    :      Optional[Any]       = attention_dropout
										lowercase    :      Any       = activation_dropout
										lowercase    :      List[str]       = activation_function
										lowercase    :      List[str]       = init_std
										lowercase    :      List[str]       = init_xavier_std
										lowercase    :      int       = encoder_layerdrop
										lowercase    :      str       = auxiliary_loss
										lowercase    :      str       = position_embedding_type
										lowercase    :      int       = backbone
										lowercase    :      List[Any]       = use_pretrained_backbone
										lowercase    :      List[str]       = dilation
										# deformable attributes
										lowercase    :      Any       = num_feature_levels
										lowercase    :      List[Any]       = encoder_n_points
										lowercase    :      Optional[Any]       = decoder_n_points
										lowercase    :      Optional[Any]       = two_stage
										lowercase    :      Tuple       = two_stage_num_proposals
										lowercase    :      Any       = with_box_refine
										if two_stage is True and with_box_refine is False:
														raise ValueError("""If two_stage is True, with_box_refine must be True."""				)
										# Hungarian matcher
										lowercase    :      int       = class_cost
										lowercase    :      Union[str, Any]       = bbox_cost
										lowercase    :      Tuple       = giou_cost
										# Loss coefficients
										lowercase    :      str       = mask_loss_coefficient
										lowercase    :      Dict       = dice_loss_coefficient
										lowercase    :      Dict       = bbox_loss_coefficient
										lowercase    :      List[str]       = giou_loss_coefficient
										lowercase    :      Dict       = eos_coefficient
										lowercase    :      Optional[Any]       = focal_alpha
										lowercase    :      Optional[Any]       = disable_custom_kernels
										super().__init__(is_encoder_decoder=__magic_name__			, **__magic_name__				)






						@property
						def      __snake_case      (		self  :List[str]				)      ->int:
										return self.encoder_attention_heads






						@property
						def      __snake_case      (		self  :Union[str, Any]				)      ->int:
										return self.d_model






						def      __snake_case      (		self  :str				)      ->Optional[int]:
										lowercase    :      Union[str, Any]       = copy.deepcopy(self.__dict__				)
										if self.backbone_config is not None:
														lowercase    :      Tuple       = self.backbone_config.to_dict()
										lowercase    :      List[str]       = self.__class__.model_type
										return output








"""simple docstring"""







import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
				import torch

				from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin


class      UpperCamelCase		:






						def __init__(		self  :Union[str, Any]			, __magic_name__  :List[Any]			, __magic_name__  :Union[str, Any]=None			, __magic_name__  :List[Any]=None			, __magic_name__  :Dict=None			, __magic_name__  :List[Any]="resnet50"			, __magic_name__  :Tuple=3			, __magic_name__  :Optional[Any]=32			, __magic_name__  :str=3			, __magic_name__  :str=True			, __magic_name__  :Optional[Any]=True			, )      ->str:
										lowercase    :      Tuple       = parent
										lowercase    :      Tuple       = out_indices if out_indices is not None else [4]
										lowercase    :      Union[str, Any]       = stage_names
										lowercase    :      Tuple       = out_features
										lowercase    :      Optional[int]       = backbone
										lowercase    :      Optional[Any]       = batch_size
										lowercase    :      Tuple       = image_size
										lowercase    :      Union[str, Any]       = num_channels
										lowercase    :      List[Any]       = use_pretrained_backbone
										lowercase    :      str       = is_training






						def      __snake_case      (		self  :List[Any]				)      ->Optional[Any]:
										lowercase    :      Dict       = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
										lowercase    :      Optional[int]       = self.get_config()

										return config, pixel_values






						def      __snake_case      (		self  :Tuple				)      ->int:
										return TimmBackboneConfig(
										    image_size=self.image_size			, num_channels=self.num_channels			, out_features=self.out_features			, out_indices=self.out_indices			, stage_names=self.stage_names			, use_pretrained_backbone=self.use_pretrained_backbone			, backbone=self.backbone			, )






						def      __snake_case      (		self  :Any			, __magic_name__  :List[str]			, __magic_name__  :Optional[int]				)      ->Tuple:
										lowercase    :      List[str]       = TimmBackbone(config=__magic_name__				)
										model.to(__magic_name__				)
										model.eval()
										with torch.no_grad():
														lowercase    :      str       = model(__magic_name__				)
										self.parent.assertEqual(
										    result.feature_map[-1].shape			, (self.batch_size, model.channels[-1], 14, 14)			, )






						def      __snake_case      (		self  :str				)      ->Dict:
										lowercase    :      Tuple       = self.prepare_config_and_inputs()
										lowercase      ,      lowercase    :      List[Any]       = config_and_inputs
										lowercase    :      Union[str, Any]       = {"""pixel_values""": pixel_values}
										return config, inputs_dict


@require_torch
@require_timm
class      UpperCamelCase		(__snake_case						,						__snake_case						,						__snake_case						,						unittest.TestCase     ):
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		(TimmBackbone,) if is_torch_available() else ()
						_SCREAMING_SNAKE_CASE  : str												=		{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
						_SCREAMING_SNAKE_CASE  : Optional[Any]												=		False
						_SCREAMING_SNAKE_CASE  : int												=		False
						_SCREAMING_SNAKE_CASE  : List[Any]												=		False
						_SCREAMING_SNAKE_CASE  : List[str]												=		False






						def      __snake_case      (		self  :Dict				)      ->List[str]:
										lowercase    :      List[str]       = TimmBackboneModelTester(self				)
										lowercase    :      Any       = ConfigTester(self			, config_class=__magic_name__			, has_text_modality=__magic_name__				)






						def      __snake_case      (		self  :Optional[Any]				)      ->List[Any]:
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()






						def      __snake_case      (		self  :Union[str, Any]				)      ->Optional[Any]:
										lowercase    :      Dict       = """resnet18"""
										lowercase    :      int       = """microsoft/resnet-18"""

										lowercase    :      Union[str, Any]       = AutoBackbone.from_pretrained(__magic_name__			, use_timm_backbone=__magic_name__				)
										lowercase    :      int       = AutoBackbone.from_pretrained(__magic_name__				)

										self.assertEqual(len(timm_model.out_features				)			, len(transformers_model.out_features				)				)
										self.assertEqual(len(timm_model.stage_names				)			, len(transformers_model.stage_names				)				)
										self.assertEqual(timm_model.channels			, transformers_model.channels				)
										# Out indices are set to the last layer by default. For timm models, we don't know
										# the number of layers in advance, so we set it to (-1,), whereas for transformers
										# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
										self.assertEqual(timm_model.out_indices			, (-1,)				)
										self.assertEqual(transformers_model.out_indices			, [len(timm_model.stage_names				) - 1]				)

										lowercase    :      Tuple       = AutoBackbone.from_pretrained(__magic_name__			, use_timm_backbone=__magic_name__			, out_indices=[1, 2, 3]				)
										lowercase    :      Any       = AutoBackbone.from_pretrained(__magic_name__			, out_indices=[1, 2, 3]				)

										self.assertEqual(timm_model.out_indices			, transformers_model.out_indices				)
										self.assertEqual(len(timm_model.out_features				)			, len(transformers_model.out_features				)				)
										self.assertEqual(timm_model.channels			, transformers_model.channels				)






						@unittest.skip("""TimmBackbone doesn't support feed forward chunking"""				)
						def      __snake_case      (		self  :Tuple				)      ->Optional[int]:
										pass






						@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->int:
										pass






						@unittest.skip("""TimmBackbone initialization is managed on the timm side"""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[Any]:
										pass






						@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""				)
						def      __snake_case      (		self  :int				)      ->List[Any]:
										pass






						@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""				)
						def      __snake_case      (		self  :int				)      ->Tuple:
										pass






						@unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""				)
						def      __snake_case      (		self  :List[Any]				)      ->List[str]:
										pass






						@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""				)
						def      __snake_case      (		self  :int				)      ->Any:
										pass






						@unittest.skip("""model weights aren't tied in TimmBackbone."""				)
						def      __snake_case      (		self  :int				)      ->int:
										pass






						@unittest.skip("""model weights aren't tied in TimmBackbone."""				)
						def      __snake_case      (		self  :str				)      ->Union[str, Any]:
										pass






						@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""				)
						def      __snake_case      (		self  :int				)      ->Optional[int]:
										pass






						@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""				)
						def      __snake_case      (		self  :List[Any]				)      ->Optional[Any]:
										pass






						@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""				)
						def      __snake_case      (		self  :Union[str, Any]				)      ->List[Any]:
										pass






						@unittest.skip("""TimmBackbone doesn't support output_attentions."""				)
						def      __snake_case      (		self  :Tuple				)      ->List[Any]:
										pass






						@unittest.skip("""Safetensors is not supported by timm."""				)
						def      __snake_case      (		self  :List[Any]				)      ->int:
										pass






						@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[int]:
										pass






						def      __snake_case      (		self  :Union[str, Any]				)      ->Union[str, Any]:
										lowercase      ,      lowercase    :      Optional[Any]       = self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowercase    :      str       = model_class(__magic_name__				)
														lowercase    :      int       = inspect.signature(model.forward				)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														lowercase    :      Any       = [*signature.parameters.keys()]

														lowercase    :      Dict       = ["""pixel_values"""]
														self.assertListEqual(arg_names[:1]			, __magic_name__				)






						def      __snake_case      (		self  :Any				)      ->List[str]:
										lowercase      ,      lowercase    :      str       = self.model_tester.prepare_config_and_inputs_for_common()
										lowercase    :      Any       = True
										lowercase    :      int       = self.has_attentions

										# no need to test all models as different heads yield the same functionality
										lowercase    :      Union[str, Any]       = self.all_model_classes[0]
										lowercase    :      Tuple       = model_class(__magic_name__				)
										model.to(__magic_name__				)

										lowercase    :      Optional[Any]       = self._prepare_for_class(__magic_name__			, __magic_name__				)
										lowercase    :      Dict       = model(**__magic_name__				)
										lowercase    :      List[str]       = outputs[0][-1]

										# Encoder-/Decoder-only models
										lowercase    :      str       = outputs.hidden_states[0]
										hidden_states.retain_grad()

										if self.has_attentions:
														lowercase    :      List[Any]       = outputs.attentions[0]
														attentions.retain_grad()

										output.flatten()[0].backward(retain_graph=__magic_name__				)

										self.assertIsNotNone(hidden_states.grad				)

										if self.has_attentions:
														self.assertIsNotNone(attentions.grad				)






						def      __snake_case      (		self  :Any				)      ->List[Any]:
										lowercase      ,      lowercase    :      int       = self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowercase    :      Optional[int]       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Any       = model(**__magic_name__				)

														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    :      List[Any]       = copy.deepcopy(__magic_name__				)
														lowercase    :      Dict       = None
														lowercase    :      str       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Optional[Any]       = model(**__magic_name__				)

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

														# Check backbone can be initialized with fresh weights
														lowercase    :      str       = copy.deepcopy(__magic_name__				)
														lowercase    :      int       = False
														lowercase    :      List[str]       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Dict       = model(**__magic_name__				)
