





'''simple docstring'''

import copy

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


a        =						logging.get_logger(__name__)

a        =						{
    "ut/deta": "https://huggingface.co/ut/deta/resolve/main/config.json",
}







class __a (   _snake_case			):
   __UpperCamelCase   : Dict	      =	'deta'
   __UpperCamelCase   : List[str]	      =	{
       'hidden_size': 'd_model',
       'num_attention_heads': 'encoder_attention_heads',
   }





   def __init__(					self				:			Tuple				,lowerCamelCase				:			List[Any]=None				,lowerCamelCase				:			Any=900				,lowerCamelCase				:			int=2048				,lowerCamelCase				:			Any=6				,lowerCamelCase				:			Optional[Any]=2048				,lowerCamelCase				:			str=8				,lowerCamelCase				:			Union[str, Any]=6				,lowerCamelCase				:			List[str]=1024				,lowerCamelCase				:			int=8				,lowerCamelCase				:			Any=0.0				,lowerCamelCase				:			Any=True				,lowerCamelCase				:			Optional[int]="relu"				,lowerCamelCase				:			int=256				,lowerCamelCase				:			Tuple=0.1				,lowerCamelCase				:			Optional[Any]=0.0				,lowerCamelCase				:			Tuple=0.0				,lowerCamelCase				:			List[str]=0.02				,lowerCamelCase				:			Any=1.0				,lowerCamelCase				:			Optional[int]=True				,lowerCamelCase				:			int=False				,lowerCamelCase				:			Optional[Any]="sine"				,lowerCamelCase				:			Dict=5				,lowerCamelCase				:			List[Any]=4				,lowerCamelCase				:			Optional[Any]=4				,lowerCamelCase				:			Any=True				,lowerCamelCase				:			int=300				,lowerCamelCase				:			Any=True				,lowerCamelCase				:			Tuple=True				,lowerCamelCase				:			int=1				,lowerCamelCase				:			Tuple=5				,lowerCamelCase				:			Union[str, Any]=2				,lowerCamelCase				:			Tuple=1				,lowerCamelCase				:			int=1				,lowerCamelCase				:			str=5				,lowerCamelCase				:			Optional[Any]=2				,lowerCamelCase				:			List[Any]=0.1				,lowerCamelCase				:			Union[str, Any]=0.25				,**lowerCamelCase				:			int				,):

      '''simple docstring'''

      if backbone_config is None:
         logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""    )
         __SCREAMING_SNAKE_CASE      							=       CONFIG_MAPPING["""resnet"""](out_features=["""stage2""", """stage3""", """stage4"""]    )
      else:
         if isinstance(lowerCamelCase				,lowerCamelCase    ):
            __SCREAMING_SNAKE_CASE      							=       backbone_config.pop("""model_type"""    )
            __SCREAMING_SNAKE_CASE      							=       CONFIG_MAPPING[backbone_model_type]
            __SCREAMING_SNAKE_CASE      							=       config_class.from_dict(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       backbone_config
      __SCREAMING_SNAKE_CASE      							=       num_queries
      __SCREAMING_SNAKE_CASE      							=       max_position_embeddings
      __SCREAMING_SNAKE_CASE      							=       d_model
      __SCREAMING_SNAKE_CASE      							=       encoder_ffn_dim
      __SCREAMING_SNAKE_CASE      							=       encoder_layers
      __SCREAMING_SNAKE_CASE      							=       encoder_attention_heads
      __SCREAMING_SNAKE_CASE      							=       decoder_ffn_dim
      __SCREAMING_SNAKE_CASE      							=       decoder_layers
      __SCREAMING_SNAKE_CASE      							=       decoder_attention_heads
      __SCREAMING_SNAKE_CASE      							=       dropout
      __SCREAMING_SNAKE_CASE      							=       attention_dropout
      __SCREAMING_SNAKE_CASE      							=       activation_dropout
      __SCREAMING_SNAKE_CASE      							=       activation_function
      __SCREAMING_SNAKE_CASE      							=       init_std
      __SCREAMING_SNAKE_CASE      							=       init_xavier_std
      __SCREAMING_SNAKE_CASE      							=       encoder_layerdrop
      __SCREAMING_SNAKE_CASE      							=       auxiliary_loss
      __SCREAMING_SNAKE_CASE      							=       position_embedding_type
      # deformable attributes
      __SCREAMING_SNAKE_CASE      							=       num_feature_levels
      __SCREAMING_SNAKE_CASE      							=       encoder_n_points
      __SCREAMING_SNAKE_CASE      							=       decoder_n_points
      __SCREAMING_SNAKE_CASE      							=       two_stage
      __SCREAMING_SNAKE_CASE      							=       two_stage_num_proposals
      __SCREAMING_SNAKE_CASE      							=       with_box_refine
      __SCREAMING_SNAKE_CASE      							=       assign_first_stage
      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
      __SCREAMING_SNAKE_CASE      							=       class_cost
      __SCREAMING_SNAKE_CASE      							=       bbox_cost
      __SCREAMING_SNAKE_CASE      							=       giou_cost
      # Loss coefficients
      __SCREAMING_SNAKE_CASE      							=       mask_loss_coefficient
      __SCREAMING_SNAKE_CASE      							=       dice_loss_coefficient
      __SCREAMING_SNAKE_CASE      							=       bbox_loss_coefficient
      __SCREAMING_SNAKE_CASE      							=       giou_loss_coefficient
      __SCREAMING_SNAKE_CASE      							=       eos_coefficient
      __SCREAMING_SNAKE_CASE      							=       focal_alpha
      super().__init__(is_encoder_decoder=lowerCamelCase				,**lowerCamelCase    )





   @property
   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      return self.encoder_attention_heads





   @property
   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      return self.d_model





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       copy.deepcopy(self.__dict__    )
      __SCREAMING_SNAKE_CASE      							=       self.backbone_config.to_dict()
      __SCREAMING_SNAKE_CASE      							=       self.__class__.model_type
      return output












'''simple docstring'''

import math
from enum import Enum
from typing import Optional, Union

from torch.optim import Optimizer
from torch.optim.lr_scheduler import LambdaLR

from .utils import logging


a        =						logging.get_logger(__name__)







class __a (   _snake_case			):
   __UpperCamelCase   : int	      =	'linear'
   __UpperCamelCase   : Tuple	      =	'cosine'
   __UpperCamelCase   : Tuple	      =	'cosine_with_restarts'
   __UpperCamelCase   : List[Any]	      =	'polynomial'
   __UpperCamelCase   : Optional[Any]	      =	'constant'
   __UpperCamelCase   : Optional[int]	      =	'constant_with_warmup'
   __UpperCamelCase   : List[Any]	      =	'piecewise_constant'





def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase = -1      )						->					int:

   '''simple docstring'''







   return LambdaLR(__UpperCAmelCase							,	lambda __UpperCAmelCase      : 1							,	last_epoch=__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = -1      )						->					List[Any]:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1.0							,	__UpperCAmelCase      )      )
      return 1.0

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = -1      )						->					int:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       {}
   __SCREAMING_SNAKE_CASE      							=       step_rules.split(""","""      )
   for rule_str in rule_list[:-1]:
      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       rule_str.split(""":"""      )
      __SCREAMING_SNAKE_CASE      							=       int(__UpperCAmelCase      )
      __SCREAMING_SNAKE_CASE      							=       float(__UpperCAmelCase      )
      __SCREAMING_SNAKE_CASE      							=       value
   __SCREAMING_SNAKE_CASE      							=       float(rule_list[-1]      )

   def create_rules_function(__UpperCAmelCase							,	__UpperCAmelCase      ):
      def rule_func(__UpperCAmelCase      ) -> float:
         __SCREAMING_SNAKE_CASE      							=       sorted(rules_dict.keys()      )
         for i, sorted_step in enumerate(__UpperCAmelCase      ):
            if steps < sorted_step:
               return rules_dict[sorted_steps[i]]
         return last_lr_multiple

      return rule_func

   __SCREAMING_SNAKE_CASE      							=       create_rules_function(__UpperCAmelCase							,	__UpperCAmelCase      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase=-1      )						->					int:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      return max(
          0.0							,	float(num_training_steps - current_step      ) / float(max(1							,	num_training_steps - num_warmup_steps      )      )      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = 0.5							,	__UpperCAmelCase = -1      )						->					Dict:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      __SCREAMING_SNAKE_CASE      							=       float(current_step - num_warmup_steps      ) / float(max(1							,	num_training_steps - num_warmup_steps      )      )
      return max(0.0							,	0.5 * (1.0 + math.cos(math.pi * float(__UpperCAmelCase      ) * 2.0 * progress      ))      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = 1							,	__UpperCAmelCase = -1      )						->					Tuple:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      __SCREAMING_SNAKE_CASE      							=       float(current_step - num_warmup_steps      ) / float(max(1							,	num_training_steps - num_warmup_steps      )      )
      if progress >= 1.0:
         return 0.0
      return max(0.0							,	0.5 * (1.0 + math.cos(math.pi * ((float(__UpperCAmelCase      ) * progress) % 1.0)      ))      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase=1e-7							,	__UpperCAmelCase=1.0							,	__UpperCAmelCase=-1      )						->					Tuple:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       optimizer.defaults["""lr"""]
   if not (lr_init > lr_end):
      raise ValueError(f"""lr_end ({lr_end}) must be be smaller than initial lr ({lr_init})"""      )

   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      elif current_step > num_training_steps:
         return lr_end / lr_init  # as LambdaLR multiplies by lr_init
      else:
         __SCREAMING_SNAKE_CASE      							=       lr_init - lr_end
         __SCREAMING_SNAKE_CASE      							=       num_training_steps - num_warmup_steps
         __SCREAMING_SNAKE_CASE      							=       1 - (current_step - num_warmup_steps) / decay_steps
         __SCREAMING_SNAKE_CASE      							=       lr_range * pct_remaining**power + lr_end
         return decay / lr_init  # as LambdaLR multiplies by lr_init

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )


a        =						{
    SchedulerType.LINEAR: get_linear_schedule_with_warmup,
    SchedulerType.COSINE: get_cosine_schedule_with_warmup,
    SchedulerType.COSINE_WITH_RESTARTS: get_cosine_with_hard_restarts_schedule_with_warmup,
    SchedulerType.POLYNOMIAL: get_polynomial_decay_schedule_with_warmup,
    SchedulerType.CONSTANT: get_constant_schedule,
    SchedulerType.CONSTANT_WITH_WARMUP: get_constant_schedule_with_warmup,
    SchedulerType.PIECEWISE_CONSTANT: get_piecewise_constant_schedule,
}







def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = None							,	__UpperCAmelCase = None							,	__UpperCAmelCase = None							,	__UpperCAmelCase = 1							,	__UpperCAmelCase = 1.0							,	__UpperCAmelCase = -1							,	)						->					str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       SchedulerType(__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       TYPE_TO_SCHEDULER_FUNCTION[name]
   if name == SchedulerType.CONSTANT:
      return schedule_func(__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

   if name == SchedulerType.PIECEWISE_CONSTANT:
      return schedule_func(__UpperCAmelCase							,	step_rules=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

   # All other schedulers require `num_warmup_steps`
   if num_warmup_steps is None:
      raise ValueError(f"""{name} requires `num_warmup_steps`, please provide that argument."""      )

   if name == SchedulerType.CONSTANT_WITH_WARMUP:
      return schedule_func(__UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

   # All other schedulers require `num_training_steps`
   if num_training_steps is None:
      raise ValueError(f"""{name} requires `num_training_steps`, please provide that argument."""      )

   if name == SchedulerType.COSINE_WITH_RESTARTS:
      return schedule_func(
          __UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	num_training_steps=__UpperCAmelCase							,	num_cycles=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase							,	)

   if name == SchedulerType.POLYNOMIAL:
      return schedule_func(
          __UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	num_training_steps=__UpperCAmelCase							,	power=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase							,	)

   return schedule_func(
       __UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	num_training_steps=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )





