
"""simple docstring"""





import copy

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


_a														=		logging.get_logger(__name__)

_a														=		{
    """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(    lowerCamelCase	):
		lowercase__						=      'deformable_detr'
		lowercase__						=      {
		    'hidden_size': 'd_model',
		    'num_attention_heads': 'encoder_attention_heads',
		}



		def __init__(					self				,		__a=True				,		__a=None				,		__a=3				,		__a=3_00				,		__a=10_24				,		__a=6				,		__a=10_24				,		__a=8				,		__a=6				,		__a=10_24				,		__a=8				,		__a=0.0				,		__a=True				,		__a="relu"				,		__a=2_56				,		__a=0.1				,		__a=0.0				,		__a=0.0				,		__a=0.02				,		__a=1.0				,		__a=True				,		__a=False				,		__a="sine"				,		__a="resnet50"				,		__a=True				,		__a=False				,		__a=4				,		__a=4				,		__a=4				,		__a=False				,		__a=3_00				,		__a=False				,		__a=1				,		__a=5				,		__a=2				,		__a=1				,		__a=1				,		__a=5				,		__a=2				,		__a=0.1				,		__a=0.25				,		__a=False				,		**__a				,		)       ->       int:






							'''simple docstring'''
							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.''')
																	_UpperCamelCase							 =  CONFIG_MAPPING['''resnet'''](out_features=['''stage4'''])
												elif isinstance(__a				,		__a):
																	_UpperCamelCase							 =  backbone_config.get('''model_type''')
																	_UpperCamelCase							 =  CONFIG_MAPPING[backbone_model_type]
																	_UpperCamelCase							 =  config_class.from_dict(__a)
							_UpperCamelCase							 =  use_timm_backbone
							_UpperCamelCase							 =  backbone_config
							_UpperCamelCase							 =  num_channels
							_UpperCamelCase							 =  num_queries
							_UpperCamelCase							 =  max_position_embeddings
							_UpperCamelCase							 =  d_model
							_UpperCamelCase							 =  encoder_ffn_dim
							_UpperCamelCase							 =  encoder_layers
							_UpperCamelCase							 =  encoder_attention_heads
							_UpperCamelCase							 =  decoder_ffn_dim
							_UpperCamelCase							 =  decoder_layers
							_UpperCamelCase							 =  decoder_attention_heads
							_UpperCamelCase							 =  dropout
							_UpperCamelCase							 =  attention_dropout
							_UpperCamelCase							 =  activation_dropout
							_UpperCamelCase							 =  activation_function
							_UpperCamelCase							 =  init_std
							_UpperCamelCase							 =  init_xavier_std
							_UpperCamelCase							 =  encoder_layerdrop
							_UpperCamelCase							 =  auxiliary_loss
							_UpperCamelCase							 =  position_embedding_type
							_UpperCamelCase							 =  backbone
							_UpperCamelCase							 =  use_pretrained_backbone
							_UpperCamelCase							 =  dilation
							# deformable attributes
							_UpperCamelCase							 =  num_feature_levels
							_UpperCamelCase							 =  encoder_n_points
							_UpperCamelCase							 =  decoder_n_points
							_UpperCamelCase							 =  two_stage
							_UpperCamelCase							 =  two_stage_num_proposals
							_UpperCamelCase							 =  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
							_UpperCamelCase							 =  class_cost
							_UpperCamelCase							 =  bbox_cost
							_UpperCamelCase							 =  giou_cost
							# Loss coefficients
							_UpperCamelCase							 =  mask_loss_coefficient
							_UpperCamelCase							 =  dice_loss_coefficient
							_UpperCamelCase							 =  bbox_loss_coefficient
							_UpperCamelCase							 =  giou_loss_coefficient
							_UpperCamelCase							 =  eos_coefficient
							_UpperCamelCase							 =  focal_alpha
							_UpperCamelCase							 =  disable_custom_kernels
							super().__init__(is_encoder_decoder=__a				,		**__a)



		@property
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							return self.encoder_attention_heads



		@property
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							return self.d_model




		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  copy.deepcopy(self.__dict__)
							if self.backbone_config is not None:
												_UpperCamelCase							 =  self.backbone_config.to_dict()
							_UpperCamelCase							 =  self.__class__.model_type
							return output








"""simple docstring"""





import torch
from torch import nn






class     _UpperCAmelCase(    nn.Module	):



		def __init__(					self				,		__a				,		__a				,		__a				,		__a				,		__a=1				,		__a=False)       ->       Tuple:






							'''simple docstring'''
							super().__init__()

							_UpperCamelCase							 =  n_token
							_UpperCamelCase							 =  d_embed
							_UpperCamelCase							 =  d_proj

							_UpperCamelCase							 =  cutoffs + [n_token]
							_UpperCamelCase							 =  [0] + self.cutoffs
							_UpperCamelCase							 =  div_val

							_UpperCamelCase							 =  self.cutoffs[0]
							_UpperCamelCase							 =  len(self.cutoffs) - 1
							_UpperCamelCase							 =  self.shortlist_size + self.n_clusters

							if self.n_clusters > 0:
												_UpperCamelCase							 =  nn.Parameter(torch.zeros(self.n_clusters				,		self.d_embed))
												_UpperCamelCase							 =  nn.Parameter(torch.zeros(self.n_clusters))

							_UpperCamelCase							 =  nn.ModuleList()
							_UpperCamelCase							 =  nn.ParameterList()

							if div_val == 1:
												for i in range(len(self.cutoffs)):
																	if d_proj != d_embed:
																						self.out_projs.append(nn.Parameter(torch.FloatTensor(__a				,		__a)))
																	else:
																						self.out_projs.append(__a)

												self.out_layers.append(nn.Linear(__a				,		__a))
							else:
												for i in range(len(self.cutoffs)):
																	_UpperCamelCase ,  _UpperCamelCase							 =  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																	_UpperCamelCase							 =  d_embed // (div_val**i)

																	self.out_projs.append(nn.Parameter(torch.FloatTensor(__a				,		__a)))

																	self.out_layers.append(nn.Linear(__a				,		r_idx - l_idx))

							_UpperCamelCase							 =  keep_order



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a				,		__a)       ->       Any:






							'''simple docstring'''
							if proj is None:
												_UpperCamelCase							 =  nn.functional.linear(__a				,		__a				,		bias=__a)
							else:
												# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
												_UpperCamelCase							 =  nn.functional.linear(__a				,		proj.t().contiguous())
												_UpperCamelCase							 =  nn.functional.linear(__a				,		__a				,		bias=__a)
												# else:
												#     logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t()))
												#     if bias is not None:
												#         logit = logit + bias

							return logit



		def 						UpperCAmelCase							(					self				,		__a				,		__a=None				,		__a=False)       ->       Dict:






							'''simple docstring'''

							if labels is not None:
												# Shift so that tokens < n predict n
												_UpperCamelCase							 =  hidden[..., :-1, :].contiguous()
												_UpperCamelCase							 =  labels[..., 1:].contiguous()
												_UpperCamelCase							 =  hidden.view(-1				,		hidden.size(-1))
												_UpperCamelCase							 =  labels.view(-1)
												if hidden.size(0) != labels.size(0):
																	raise RuntimeError('''Input and labels should have the same size in the batch dimension.''')
							else:
												_UpperCamelCase							 =  hidden.view(-1				,		hidden.size(-1))

							if self.n_clusters == 0:
												_UpperCamelCase							 =  self._compute_logit(__a				,		self.out_layers[0].weight				,		self.out_layers[0].bias				,		self.out_projs[0])
												if labels is not None:
																	_UpperCamelCase							 =  labels != -1_00
																	_UpperCamelCase							 =  torch.zeros_like(__a				,		dtype=hidden.dtype				,		device=hidden.device)
																	_UpperCamelCase							 =  (
																	    -nn.functional.log_softmax(__a				,		dim=-1)[mask].gather(1				,		labels[mask].unsqueeze(1)).squeeze(1)
																	)
												else:
																	_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=-1)
							else:
												# construct weights and biases
												_UpperCamelCase ,  _UpperCamelCase							 =  [], []
												for i in range(len(self.cutoffs)):
																	if self.div_val == 1:
																						_UpperCamelCase ,  _UpperCamelCase							 =  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																						_UpperCamelCase							 =  self.out_layers[0].weight[l_idx:r_idx]
																						_UpperCamelCase							 =  self.out_layers[0].bias[l_idx:r_idx]
																	else:
																						_UpperCamelCase							 =  self.out_layers[i].weight
																						_UpperCamelCase							 =  self.out_layers[i].bias

																	if i == 0:
																						_UpperCamelCase							 =  torch.cat([weight_i, self.cluster_weight]				,		dim=0)
																						_UpperCamelCase							 =  torch.cat([bias_i, self.cluster_bias]				,		dim=0)

																	weights.append(__a)
																	biases.append(__a)

												_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[0], biases[0], self.out_projs[0]

												_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)
												_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)

												if labels is None:
																	_UpperCamelCase							 =  hidden.new_empty((head_logit.size(0), self.n_token))
												else:
																	_UpperCamelCase							 =  torch.zeros_like(__a				,		dtype=hidden.dtype				,		device=hidden.device)

												_UpperCamelCase							 =  0
												_UpperCamelCase							 =  [0] + self.cutoffs
												for i in range(len(__a) - 1):
																	_UpperCamelCase ,  _UpperCamelCase							 =  cutoff_values[i], cutoff_values[i + 1]

																	if labels is not None:
																						_UpperCamelCase							 =  (labels >= l_idx) & (labels < r_idx)
																						_UpperCamelCase							 =  mask_i.nonzero().squeeze()

																						if indices_i.numel() == 0:
																											continue

																						_UpperCamelCase							 =  labels.index_select(0				,		__a) - l_idx
																						_UpperCamelCase							 =  head_logprob.index_select(0				,		__a)
																						_UpperCamelCase							 =  hidden.index_select(0				,		__a)
																	else:
																						_UpperCamelCase							 =  hidden

																	if i == 0:
																						if labels is not None:
																											_UpperCamelCase							 =  head_logprob_i.gather(1				,		target_i[:, None]).squeeze(1)
																						else:
																											_UpperCamelCase							 =  head_logprob[:, : self.cutoffs[0]]
																	else:
																						_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[i], biases[i], self.out_projs[i]

																						_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)
																						_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)
																						_UpperCamelCase							 =  self.cutoffs[0] + i - 1  # No probability for the head cluster
																						if labels is not None:
																											_UpperCamelCase							 =  head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
																											    1				,		target_i[:, None]).squeeze(1)
																						else:
																											_UpperCamelCase							 =  head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
																											_UpperCamelCase							 =  logprob_i

																	if labels is not None:
																						if (hasattr(self				,		'''keep_order''') and self.keep_order) or keep_order:
																											out.index_copy_(0				,		__a				,		-logprob_i)
																						else:
																											out[offset : offset + logprob_i.size(0)].copy_(-logprob_i)
																						offset += logprob_i.size(0)

							return out




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






							'''simple docstring'''
							if self.n_clusters == 0:
												_UpperCamelCase							 =  self._compute_logit(__a				,		self.out_layers[0].weight				,		self.out_layers[0].bias				,		self.out_projs[0])
												return nn.functional.log_softmax(__a				,		dim=-1)
							else:
												# construct weights and biases
												_UpperCamelCase ,  _UpperCamelCase							 =  [], []
												for i in range(len(self.cutoffs)):
																	if self.div_val == 1:
																						_UpperCamelCase ,  _UpperCamelCase							 =  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																						_UpperCamelCase							 =  self.out_layers[0].weight[l_idx:r_idx]
																						_UpperCamelCase							 =  self.out_layers[0].bias[l_idx:r_idx]
																	else:
																						_UpperCamelCase							 =  self.out_layers[i].weight
																						_UpperCamelCase							 =  self.out_layers[i].bias

																	if i == 0:
																						_UpperCamelCase							 =  torch.cat([weight_i, self.cluster_weight]				,		dim=0)
																						_UpperCamelCase							 =  torch.cat([bias_i, self.cluster_bias]				,		dim=0)

																	weights.append(__a)
																	biases.append(__a)

												_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[0], biases[0], self.out_projs[0]
												_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)

												_UpperCamelCase							 =  hidden.new_empty((head_logit.size(0), self.n_token))
												_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)

												_UpperCamelCase							 =  [0] + self.cutoffs
												for i in range(len(__a) - 1):
																	_UpperCamelCase ,  _UpperCamelCase							 =  cutoff_values[i], cutoff_values[i + 1]

																	if i == 0:
																						_UpperCamelCase							 =  head_logprob[:, : self.cutoffs[0]]
																	else:
																						_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[i], biases[i], self.out_projs[i]

																						_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)
																						_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)

																						_UpperCamelCase							 =  head_logprob[:, -i] + tail_logprob_i
																						_UpperCamelCase							 =  logprob_i

												return out






