# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨 # This file was automatically generated from src/transformers/models/lw_detr/modular_lw_detr.py. # Do NOT edit this file manually as any edits will be overwritten by the generation of # the file from the modular. If any change should be done, please apply the change to the # modular_lw_detr.py file directly. One of our CI enforces this. # 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨 # Copyright 2026 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import math from ...backbone_utils import BackboneConfigMixin, consolidate_backbone_kwargs_to_config from ...configuration_utils import PreTrainedConfig from ..auto import AutoConfig class LwDetrViTConfig(BackboneConfigMixin, PreTrainedConfig): r""" This is the configuration class to store the configuration of a [`LwDetrViTModel`]. It is used to instantiate an LW-DETR ViT model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the LW-DETR ViT [AnnaZhang/lwdetr_small_60e_coco](https://huggingface.co/AnnaZhang/lwdetr_small_60e_coco) architecture. LW-DETR ViT is the Vision Transformer backbone used in the LW-DETR model for real-time object detection. It features interleaved window and global attention mechanisms to reduce computational complexity while maintaining high performance. The model uses a window-major feature map organization for efficient attention computation. Configuration objects inherit from [`VitDetConfig`] and can be used to control the model outputs. Read the documentation from [`VitDetConfig`] for more information. Args: hidden_size (`int`, *optional*, defaults to 768): Dimensionality of the encoder layers and the pooler layer. num_hidden_layers (`int`, *optional*, defaults to 12): Number of hidden layers in the Transformer encoder. num_attention_heads (`int`, *optional*, defaults to 12): Number of attention heads for each attention layer in the Transformer encoder. mlp_ratio (`int`, *optional*, defaults to 4): Ratio of mlp hidden dim to embedding dim. hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`): The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported. dropout_prob (`float`, *optional*, defaults to 0.0): The dropout probability for all fully connected layers in the embeddings, encoder, and pooler. initializer_range (`float`, *optional*, defaults to 0.02): The standard deviation of the truncated_normal_initializer for initializing all weight matrices. layer_norm_eps (`float`, *optional*, defaults to 1e-06): The epsilon used by the layer normalization layers. image_size (`int`, *optional*, defaults to 256): The size (resolution) of each image. pretrain_image_size (`int`, *optional*, defaults to 224): The size (resolution) of each image during pretraining. patch_size (`int`, *optional*, defaults to 16): The size (resolution) of each patch. num_channels (`int`, *optional*, defaults to 3): The number of input channels. qkv_bias (`bool`, *optional*, defaults to `True`): Whether to add a bias to the queries, keys and values. window_block_indices (`list[int]`, *optional*, defaults to `[]`): List of indices of blocks that should have window attention instead of regular global self-attention. use_absolute_position_embeddings (`bool`, *optional*, defaults to `True`): Whether to add absolute position embeddings to the patch embeddings. out_features (`list[str]`, *optional*): If used as backbone, list of features to output. Can be any of `"stem"`, `"stage1"`, `"stage2"`, etc. (depending on how many stages the model has). If unset and `out_indices` is set, will default to the corresponding stages. If unset and `out_indices` is unset, will default to the last stage. Must be in the same order as defined in the `stage_names` attribute. out_indices (`list[int]`, *optional*): If used as backbone, list of indices of features to output. Can be any of 0, 1, 2, etc. (depending on how many stages the model has). If unset and `out_features` is set, will default to the corresponding stages. If unset and `out_features` is unset, will default to the last stage. Must be in the same order as defined in the `stage_names` attribute. cae_init_values (`float`, *optional*, defaults to 0.1): Initialization value for CAE parameters when `use_cae` is enabled. num_windows (`int`, *optional*, defaults to 16): Number of windows for window-based attention. Must be a perfect square and the image size must be divisible by the square root of this value. This enables efficient window-major feature map organization. Example: ```python >>> from transformers import LwDetrViTConfig, LwDetrViTModel >>> # Initializing a LW-DETR ViT configuration >>> configuration = LwDetrViTConfig() >>> # Initializing a model (with random weights) from the configuration >>> model = LwDetrViTModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ```""" model_type = "lw_detr_vit" def __init__( self, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, mlp_ratio=4, hidden_act="gelu", dropout_prob=0.0, initializer_range=0.02, layer_norm_eps=1e-6, image_size=256, pretrain_image_size=224, patch_size=16, num_channels=3, qkv_bias=True, window_block_indices=[], use_absolute_position_embeddings=True, out_features=None, out_indices=None, cae_init_values: float = 0.1, num_windows=16, **kwargs, ): super().__init__(**kwargs) self.hidden_size = hidden_size self.num_hidden_layers = num_hidden_layers self.num_attention_heads = num_attention_heads self.mlp_ratio = mlp_ratio self.hidden_act = hidden_act self.dropout_prob = dropout_prob self.initializer_range = initializer_range self.layer_norm_eps = layer_norm_eps self.image_size = image_size self.pretrain_image_size = pretrain_image_size self.patch_size = patch_size self.num_channels = num_channels self.qkv_bias = qkv_bias self.window_block_indices = window_block_indices self.use_absolute_position_embeddings = use_absolute_position_embeddings self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, self.num_hidden_layers + 1)] self.set_output_features_output_indices(out_indices=out_indices, out_features=out_features) self.cae_init_values = cae_init_values if num_windows % math.sqrt(num_windows) != 0: raise ValueError( f"`num_windows` has to be a perfect square, where num_windows % math.sqrt(num_windows) != 0, but got {num_windows}." ) if image_size / num_windows % math.sqrt(num_windows) != 0: raise ValueError( f"`image_size` has to be divisible by `num_windows`, where image_size / num_windows % math.sqrt(num_windows) != 0,but got {image_size} and {num_windows}." ) self.num_windows = num_windows self.num_windows_side = int(math.sqrt(num_windows)) class LwDetrConfig(PreTrainedConfig): r""" This is the configuration class to store the configuration of a [`LwDetrModel`]. It is used to instantiate a LW-DETR model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the LW-DETR [AnnaZhang/lwdetr_small_60e_coco](https://huggingface.co/AnnaZhang/lwdetr_small_60e_coco) architecture. LW-DETR (Lightweight Detection Transformer) is a transformer-based object detection model designed for real-time detection tasks. It replaces traditional CNN-based detectors like YOLO with a more efficient transformer architecture that achieves competitive performance while being computationally lightweight. Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information. Args: backbone_config (`PretrainedConfig` or `dict`, *optional*): The configuration of the backbone model. If not provided, will default to `LwDetrViTConfig` with a small ViT architecture optimized for detection tasks. projector_scale_factors (`list[float]`, *optional*, defaults to `[]`): Scale factors for the feature pyramid network. Each scale factor determines the resolution of features at different levels. Supported values are 0.5, 1.0, and 2.0. hidden_expansion (`float`, *optional*, defaults to 0.5): Expansion factor for hidden dimensions in the projector layers. c2f_num_blocks (`int`, *optional*, defaults to 3): Number of blocks in the C2F layer. activation_function (`str`, *optional*, defaults to `"silu"`): The non-linear activation function in the projector. Supported values are `"silu"`, `"relu"`, `"gelu"`. batch_norm_eps (`float`, *optional*, defaults to 1e-05): The epsilon value for batch normalization layers. d_model (`int`, *optional*, defaults to 256): Dimension of the model layers and the number of expected features in the decoder inputs. dropout (`float`, *optional*, defaults to 0.1): The dropout probability for all fully connected layers in the embeddings, encoder, and pooler. decoder_ffn_dim (`int`, *optional*, defaults to 2048): Dimension of the "intermediate" (often named feed-forward) layer in decoder. decoder_n_points (`int`, *optional*, defaults to 4): The number of sampled keys in each feature level for each attention head in the decoder. decoder_layers (`int`, *optional*, defaults to 3): Number of decoder layers in the transformer. decoder_self_attention_heads (`int`, *optional*, defaults to 8): Number of attention heads for each attention layer in the decoder self-attention. decoder_cross_attention_heads (`int`, *optional*, defaults to 16): Number of attention heads for each attention layer in the decoder cross-attention. decoder_activation_function (`str`, *optional*, defaults to `"relu"`): The non-linear activation function in the decoder. Supported values are `"relu"`, `"silu"`, `"gelu"`. num_queries (`int`, *optional*, defaults to 300): Number of object queries, i.e. detection slots. This is the maximal number of objects [`LwDetrModel`] can detect in a single image. attention_bias (`bool`, *optional*, defaults to `True`): Whether to add bias to the attention layers. attention_dropout (`float`, *optional*, defaults to 0.0): The dropout ratio for the attention probabilities. activation_dropout (`float`, *optional*, defaults to 0.0): The dropout ratio for activations inside the fully connected layer. group_detr (`int`, *optional*, defaults to 13): Number of groups for Group DETR attention mechanism, which helps reduce computational complexity. init_std (`float`, *optional*, defaults to 0.02): The standard deviation of the truncated_normal_initializer for initializing all weight matrices. disable_custom_kernels (`bool`, *optional*, defaults to `True`): Disable the use of custom CUDA and CPU kernels. This option is necessary for the ONNX export, as custom kernels are not supported by PyTorch ONNX export. class_cost (`float`, *optional*, defaults to 2): Relative weight of the classification error in the Hungarian matching cost. bbox_cost (`float`, *optional*, defaults to 5): Relative weight of the L1 error of the bounding box coordinates in the Hungarian matching cost. giou_cost (`float`, *optional*, defaults to 2): Relative weight of the generalized IoU loss of the bounding box in the Hungarian matching cost. mask_loss_coefficient (`float`, *optional*, defaults to 1): Relative weight of the Focal loss in the panoptic segmentation loss. dice_loss_coefficient (`float`, *optional*, defaults to 1): Relative weight of the DICE/F-1 loss in the panoptic segmentation loss. bbox_loss_coefficient (`float`, *optional*, defaults to 5): Relative weight of the L1 bounding box loss in the object detection loss. giou_loss_coefficient (`float`, *optional*, defaults to 2): Relative weight of the generalized IoU loss in the object detection loss. eos_coefficient (`float`, *optional*, defaults to 0.1): Relative classification weight of the 'no-object' class in the object detection loss. focal_alpha (`float`, *optional*, defaults to 0.25): Alpha parameter in the focal loss. auxiliary_loss (`bool`, *optional*, defaults to `True`): Whether auxiliary decoding losses (loss at each decoder layer) are to be used. Examples: ```python >>> from transformers import LwDetrConfig, LwDetrModel >>> # Initializing a LW-DETR AnnaZhang/lwdetr_small_60e_coco style configuration >>> configuration = LwDetrConfig() >>> # Initializing a model (with random weights) from the AnnaZhang/lwdetr_small_60e_coco style configuration >>> model = LwDetrModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ```""" model_type = "lw_detr" sub_configs = {"backbone_config": AutoConfig} def __init__( self, # backbone backbone_config=None, # projector projector_scale_factors: list[float] = [], hidden_expansion=0.5, c2f_num_blocks=3, activation_function="silu", batch_norm_eps=1e-5, # decoder d_model=256, dropout=0.1, decoder_ffn_dim=2048, decoder_n_points=4, decoder_layers: int = 3, decoder_self_attention_heads: int = 8, decoder_cross_attention_heads: int = 16, decoder_activation_function="relu", # model num_queries=300, attention_bias=True, attention_dropout=0.0, activation_dropout=0.0, group_detr: int = 13, init_std=0.02, disable_custom_kernels=True, # loss class_cost=2, bbox_cost=5, giou_cost=2, mask_loss_coefficient=1, dice_loss_coefficient=1, bbox_loss_coefficient=5, giou_loss_coefficient=2, eos_coefficient=0.1, focal_alpha=0.25, auxiliary_loss=True, **kwargs, ): self.batch_norm_eps = batch_norm_eps backbone_config, kwargs = consolidate_backbone_kwargs_to_config( backbone_config=backbone_config, default_config_type="lw_detr_vit", default_config_kwargs={ "image_size": 1024, "hidden_size": 192, "num_hidden_layers": 10, "window_block_indices": [0, 1, 3, 6, 7, 9], "out_indices": [2, 4, 5, 9], }, **kwargs, ) self.backbone_config = backbone_config # projector self.projector_scale_factors = projector_scale_factors for scale in projector_scale_factors: if scale not in [0.5, 1.0, 2.0]: raise ValueError(f"Unsupported scale factor: {scale}") self.projector_in_channels = [d_model] * len(projector_scale_factors) self.projector_out_channels = d_model self.activation_function = activation_function self.hidden_expansion = hidden_expansion self.c2f_num_blocks = c2f_num_blocks # decoder self.d_model = d_model self.dropout = dropout self.num_queries = num_queries self.decoder_ffn_dim = decoder_ffn_dim self.num_feature_levels = len(self.projector_scale_factors) self.decoder_n_points = decoder_n_points self.decoder_layers = decoder_layers self.decoder_activation_function = decoder_activation_function self.decoder_self_attention_heads = decoder_self_attention_heads self.decoder_cross_attention_heads = decoder_cross_attention_heads self.attention_bias = attention_bias self.attention_dropout = attention_dropout self.activation_dropout = activation_dropout # model self.init_std = init_std self.group_detr = group_detr # Loss self.auxiliary_loss = auxiliary_loss # Hungarian matcher self.class_cost = class_cost self.bbox_cost = bbox_cost self.giou_cost = giou_cost # Loss coefficients self.dice_loss_coefficient = dice_loss_coefficient self.bbox_loss_coefficient = bbox_loss_coefficient self.giou_loss_coefficient = giou_loss_coefficient self.eos_coefficient = eos_coefficient self.focal_alpha = focal_alpha self.disable_custom_kernels = disable_custom_kernels super().__init__(**kwargs) __all__ = ["LwDetrConfig", "LwDetrViTConfig"]