# LW-DETR

[LW-DETR](https://huggingface.co/papers/2407.17140) propone una arquitectura de Detection Transformer (DETR) de bajo peso diseñada para competir con y superar a la serie dominante YOLO en la detección de objetos en tiempo real. Logra un nuevo equilibrio óptimo entre velocidad (latencia) y precisión (mAP) al combinar avances recientes en transformers con decisiones de diseño eficientes.

La arquitectura LW-DETR se caracteriza por su estructura simple y eficiente: un codificador ViT simple, un proyector y un decodificador DETR poco profundo. Mejora la arquitectura DETR en cuanto a eficiencia y velocidad mediante las siguientes modificaciones principales:
1. Codificador ViT eficiente: utiliza un ViT simple con atención de ventana/global intercalada y una organización de ventana principal para reducir drásticamente la complejidad y la latencia de la atención.
2. Entrada más rica: agrega características de múltiples niveles del codificador y utiliza un Proyectador C2f (YOLOv8) para pasar características de dos escalas ($1/8$ y $1/32$).
3. Decodificador más rápido: Emplea un decodificador DETR poco profundo de 3 capas con atención cruzada deformable para una latencia más baja y una convergencia más rápida.
4. Consultas optimizadas: utiliza un esquema de consultas mixtas que combina consultas de contenido aprendibles y consultas espaciales generadas.

Puedes encontrar todos los puntos de control de LW DETR disponibles bajo la organización [AnnaZhang](https://huggingface.co/AnnaZhang). El código original se encuentra [aquí](https://github.com/Atten4Vis/LW-DETR).

> [!TIP]
> Este modelo fue aportado por [stevenbucaille](https://huggingface.co/stevenbucaille).
>
> Haz clic en los modelos LW-DETR en la barra lateral derecha para ver más ejemplos de cómo aplicar LW-DETR a diferentes tareas de detección de objetos.

El siguiente ejemplo demuestra cómo realizar la detección de objetos con la clase [Pipeline](/docs/transformers/main/es/main_classes/pipelines#transformers.Pipeline) y la clase [AutoModel](/docs/transformers/main/es/model_doc/auto#transformers.AutoModel).

```python

from transformers import pipeline

pipeline = pipeline(
    "object-detection",
    model="AnnaZhang/lwdetr_small_60e_coco",
    device_map=0
)

pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForObjectDetection

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
model = AutoModelForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco", device_map="auto")

# prepare image for the model
inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
```

## Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con LwDetr.

- Véase también: [Guía de la tarea de detección de objetos](../tasks/object_detection).

## LwDetrConfig[[transformers.LwDetrConfig]]

#### transformers.LwDetrConfig[[transformers.LwDetrConfig]]

```python
transformers.LwDetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projector_scale_factors: list[float] | tuple[float, ...] = (), hidden_expansion: float = 0.5, c2f_num_blocks: int = 3, activation_function: str = 'silu', batch_norm_eps: float = 1e-05, dropout: float | int = 0.0, decoder_ffn_dim: int = 2048, decoder_n_points: int = 4, decoder_layers: int = 3, decoder_self_attention_heads: int = 8, decoder_cross_attention_heads: int = 16, decoder_activation_function: str = 'relu', num_queries: int = 300, attention_bias: bool = True, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, group_detr: int = 13, init_std: float = 0.02, disable_custom_kernels: bool = True, class_cost: int | float = 2, bbox_cost: int | float = 5, giou_cost: int | float = 2, class_loss_coefficient: int | float = 1, dice_loss_coefficient: int | float = 1, bbox_loss_coefficient: int | float = 5, giou_loss_coefficient: int | float = 2, eos_coefficient: float = 0.1, focal_alpha: float = 0.25, auxiliary_loss: bool = True, d_model: int = 256)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/configuration_lw_detr.py#L109)

**Parámetros:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : La configuración del modelo de base.

projector_scale_factors (`list[float]`, *opcional*, valor predeterminado `[]`) : Factores de escala para la red de pirámide de características. Cada factor de escala determina la resolución de las características en distintos niveles. Los valores admitidos son 0.5, 1.0 y 2.0.

hidden_expansion (`float`, *opcional*, valor predeterminado 0.5) : Factor de expansión para las dimensiones ocultas en las capas del proyector.

c2f_num_blocks (`int`, *opcional*, valor predeterminado 3) : Número de bloques en la capa C2F.

activation_function (`str`, *opcional*, valor predeterminado `"silu"`) : La función de activación no lineal en el proyector. Los valores admitidos son `"silu"`, `"relu"`, `"gelu"`.

batch_norm_eps (`float`, *opcional*, valor predeterminado 1e-05) : El valor de epsilon para las capas de normalización por lote.

dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción para todas las capas de dropout.

decoder_ffn_dim (`int`, *opcional*, valor predeterminado 2048) : Dimensión de la capa "intermedia" (a menudo denominada feed-forward) en el decodificador.

decoder_n_points (`int`, *opcional*, valor predeterminado: 4) : El número de claves muestreadas en cada nivel de características para cada cabeza de atención en el decodificador.

decoder_layers (`int`, *opcional*, valor predeterminado `3`) : Número de capas ocultas en el decodificador Transformer. Usará el mismo valor que `num_layers` si no se establece.

decoder_self_attention_heads (`int`, *opcional*, valor predeterminado 8) : Número de cabezas de atención para cada capa de atención en la autoatención del decodificador.

decoder_cross_attention_heads (`int`, *opcional*, valor predeterminado 16) : Número de cabezas de atención para cada capa de atención en la atención cruzada del decodificador.

decoder_activation_function (`str`, *opcional*, valor predeterminado `"relu"`) : La función de activación no lineal en el decodificador. Los valores admitidos son `"relu"`, `"silu"`, `"gelu"`.

num_queries (`int`, *opcional*, valor predeterminado 300) : Número de consultas de objetos, es decir, ranuras de detección. Este es el número máximo de objetos que [LwDetrModel](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrModel) puede detectar en una sola imagen.

attention_bias (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

activation_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las activaciones dentro de la capa totalmente conectada.

group_detr (`int`, *opcional*, valor predeterminado 13) : Número de grupos para el mecanismo de atención de Group DETR, que ayuda a reducir la complejidad computacional.

init_std (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

disable_custom_kernels (`bool`, *opcional*, valor predeterminado `True`) : Desactiva el uso de kernels personalizados de CUDA y CPU. Esta opción es necesaria para la exportación a ONNX, ya que los kernels personalizados no son compatibles con la exportación ONNX de PyTorch.

class_cost (`Union[int, float]`, *opcional*, valor predeterminado `2`) : Peso relativo del error de clasificación en el coste de correspondencia húngara.

bbox_cost (`Union[int, float]`, *opcional*, valor predeterminado `5`) : Peso relativo del error de la caja delimitadora L1 en el costo de correspondencia húngara.

giou_cost (`Union[int, float]`, *opcional*, valor predeterminado `2`) : Peso relativo de la pérdida de IoU generalizada en el coste de correspondencia húngara.

class_loss_coefficient (`float`, *opcional*, valor predeterminado 1) : Peso relativo de la pérdida de clasificación en el coste de correspondencia húngara.

dice_loss_coefficient (`Union[int, float]`, *opcional*, valor predeterminado `1`) : Peso relativo de la pérdida dice en la pérdida de segmentación panóptica.

bbox_loss_coefficient (`Union[int, float]`, *opcional*, valor predeterminado `5`) : Peso relativo de la pérdida de caja delimitadora L1 en la pérdida de segmentación panóptica.

giou_loss_coefficient (`Union[int, float]`, *opcional*, valor predeterminado `2`) : Peso relativo de la pérdida de IoU generalizada en la pérdida de segmentación panóptica.

eos_coefficient (`float`, *opcional*, valor predeterminado `0.1`) : Peso de clasificación relativo de la clase 'no-object' en la función de pérdida de detección de objetos.

focal_alpha (`float`, *opcional*, valor predeterminado `0.25`) : Parámetro alfa en la pérdida focal.

auxiliary_loss (`bool`, *opcional*, valor predeterminado `True`) : Si se deben utilizar las pérdidas auxiliares de decodificación (pérdidas en cada capa del decodificador).

d_model (`int`, *opcional*, valor predeterminado `256`) : Tamaño de las capas del codificador y de la capa pooler.

Esta es la clase de configuración para almacenar la configuración de un LwDetrModel. Se utiliza para instanciar un modelo Lw Detr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [AnnaZhang/lwdetr_small_60e_coco](https://huggingface.co/AnnaZhang/lwdetr_small_60e_coco)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplos:

```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
```

## LwDetrViTConfig[[transformers.LwDetrViTConfig]]

#### transformers.LwDetrViTConfig[[transformers.LwDetrViTConfig]]

```python
transformers.LwDetrViTConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: int = 4, hidden_act: str = 'gelu', dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 256, pretrain_image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, window_block_indices: list[int] | tuple[int, ...] = (), use_absolute_position_embeddings: bool = True, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, cae_init_values: float = 0.1, num_windows: int = 16)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/configuration_lw_detr.py#L35)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

mlp_ratio (`int`, *opcional*, valor predeterminado `4`) : Proporción entre la dimensión oculta del MLP y la dimensión de incrustación.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción para todas las capas de dropout.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `256`) : El tamaño (resolución) de cada imagen.

pretrain_image_size (`int`, *opcional*, valor predeterminado 224) : El tamaño (resolución) de cada imagen durante el preentrenamiento.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

qkv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un sesgo a las consultas, claves y valores.

window_block_indices (`list[int]`, *opcional*, valor predeterminado `[]`) : Lista de índices de bloques que deben tener atención de ventana en lugar de la autoatención global regular.

use_absolute_position_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben añadir embeddings de posición absoluta a los embeddings de parche.

cae_init_values (`float`, *opcional*, valor predeterminado 0.1) : Valor de inicialización para los parámetros de CAE cuando `use_cae` está habilitado.

num_windows (`int`, *opcional*, valor predeterminado 16) : Número de ventanas para la atención basada en ventanas. Debe ser un cuadrado perfecto y el tamaño de la imagen debe ser divisible por la raíz cuadrada de este valor. Esto permite una organización eficiente de los mapas de características con prioridad de ventana.

Esta es la clase de configuración para almacenar la configuración de un LwDetrModel. Se utiliza para instanciar un modelo Lw Detr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [AnnaZhang/lwdetr_small_60e_coco](https://huggingface.co/AnnaZhang/lwdetr_small_60e_coco)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

```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
```

## LwDetrModel[[transformers.LwDetrModel]]

#### transformers.LwDetrModel[[transformers.LwDetrModel]]

```python
transformers.LwDetrModel(config: LwDetrConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1204)

**Parámetros:**

config ([LwDetrConfig](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo LW Detr básico (constituido por un backbone y un decodificador Transformer) que genera estados ocultos sin ningún head específico en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.LwDetrModel.forward]]

```python
forward(pixel_values: Tensor = None, pixel_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1310)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [DeformableDetrImageProcessor](/docs/transformers/main/es/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Consulte [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [DeformableDetrImageProcessor](/docs/transformers/main/es/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) para procesar las imágenes).

pixel_mask (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar realizar atención sobre los valores de píxeles de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para píxeles reales (es decir, **no enmascarados**), - 0 para píxeles de relleno (es decir, **enmascarados**).  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

**Devuelve:** `LwDetrModelOutput` o `tuple(torch.Tensor)`

Un `LwDetrModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([LwDetrConfig](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrConfig)) y las entradas.

El método forward de [LwDetrModel](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **init_reference_points** (`torch.Tensor` de forma  `(batch_size, num_queries, 4)`) -- Puntos de referencia iniciales enviados a través del decodificador Transformer.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **intermediate_hidden_states** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Estados ocultos intermedios apilados (salida de cada capa del decodificador).
- **intermediate_reference_points** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, 4)`) -- Puntos de referencia intermedios apilados (puntos de referencia de cada capa del decodificador).
- **enc_outputs_class** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`, *opcional*, devuelto cuando `config.with_box_refine=True` y `config.two_stage=True`) -- Puntuaciones de las cajas delimitadoras predichas, donde las `config.two_stage_num_proposals` cajas delimitadoras con mayor puntuación se seleccionan como propuestas de región en la primera etapa. Salida de la clasificación binaria de cajas delimitadoras (es decir, primer plano y fondo).
- **enc_outputs_coord_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, 4)`, *opcional*, se devuelve cuando `config.with_box_refine=True` y `config.two_stage=True`) -- Logits de las coordenadas de las cajas delimitadoras predichas en la primera etapa.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_attentions** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

Ejemplos:

```python
>>> from transformers import AutoImageProcessor, DeformableDetrModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
>>> model = DeformableDetrModel.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]
```

## LwDetrForObjectDetection[[transformers.LwDetrForObjectDetection]]

#### transformers.LwDetrForObjectDetection[[transformers.LwDetrForObjectDetection]]

```python
transformers.LwDetrForObjectDetection(config: LwDetrConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1540)

**Parámetros:**

config ([LwDetrConfig](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo LW DETR (constituido por un backbone y un decodificador Transformer) con cabezas de detección de objetos en la parte superior, para tareas como la detección COCO.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.LwDetrForObjectDetection.forward]]

```python
forward(pixel_values: Tensor = None, pixel_mask: typing.Optional[torch.LongTensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1554)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [DeformableDetrImageProcessor](/docs/transformers/main/es/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Consulte [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [DeformableDetrImageProcessor](/docs/transformers/main/es/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) para procesar las imágenes).

pixel_mask (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar realizar atención sobre los valores de píxeles de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para píxeles reales (es decir, **no enmascarados**), - 0 para píxeles de relleno (es decir, **enmascarados**).  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

labels (`list[Dict]` de longitud `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de bipartite matching. Lista de diccionarios, donde cada diccionario contiene al menos las siguientes 2 claves: 'class_labels' y 'boxes' (las etiquetas de clase y las cajas delimitadoras de una imagen en el lote, respectivamente). Las propias etiquetas de clase deben ser un `torch.LongTensor` de longitud `(number of bounding boxes in the image,)` y las cajas un `torch.Tensor` de forma `(number of bounding boxes in the image, 4)`.

**Devuelve:** `LwDetrObjectDetectionOutput` o `tuple(torch.Tensor)`

Un `LwDetrObjectDetectionOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([LwDetrConfig](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrConfig)) y las entradas.

El método forward de [LwDetrForObjectDetection](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrForObjectDetection) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, devuelta cuando se proporcionan `labels`) -- Pérdida total como combinación lineal de una log-verosimilitud negativa (entropía cruzada) para la predicción de clases y una pérdida de caja delimitadora. Esta última se define como una combinación lineal de la pérdida L1 y la pérdida de IoU generalizada e invariante a la escala.
- **loss_dict** (`Dict`, *opcional*) -- Un diccionario que contiene las pérdidas individuales. Útil para el registro.
- **logits** (`torch.Tensor` de forma `(batch_size, num_queries, num_classes + 1)`) -- Logits de clasificación (incluyendo no-objeto) para todas las consultas.
- **pred_boxes** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Coordenadas de cajas normalizadas para todas las consultas, representadas como (center_x, center_y, width, height). Estos valores están normalizados en [0, 1], relativos al tamaño de cada imagen individual del lote (ignorando el posible relleno). Puede usar `~DeformableDetrProcessor.post_process_object_detection` para recuperar las cajas delimitadoras no normalizadas.
- **auxiliary_outputs** (`list[Dict]`, *opcional*) -- Opcional, solo se devuelve cuando se activan las pérdidas auxiliares (es decir, `config.auxiliary_loss` está establecido en `True`) y se proporcionan etiquetas. Es una lista de diccionarios que contienen las dos claves anteriores (`logits` y `pred_boxes`) para cada capa del decodificador.
- **init_reference_points** (`torch.Tensor` de forma  `(batch_size, num_queries, 4)`) -- Puntos de referencia iniciales enviados a través del decodificador Transformer.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **intermediate_hidden_states** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Estados ocultos intermedios apilados (salida de cada capa del decodificador).
- **intermediate_reference_points** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, 4)`) -- Puntos de referencia intermedios apilados (puntos de referencia de cada capa del decodificador).
- **enc_outputs_class** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`, *opcional*, devuelto cuando `config.with_box_refine=True` y `config.two_stage=True`) -- Puntuaciones de las cajas delimitadoras predichas, donde las `config.two_stage_num_proposals` cajas delimitadoras con mayor puntuación se seleccionan como propuestas de región en la primera etapa. Salida de la clasificación binaria de cajas delimitadoras (es decir, primer plano y fondo).
- **enc_outputs_coord_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, 4)`, *opcional*, se devuelve cuando `config.with_box_refine=True` y `config.two_stage=True`) -- Logits de las coordenadas de las cajas delimitadoras predichas en la primera etapa.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_attentions** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

Ejemplos:

```python
>>> from transformers import AutoImageProcessor, LwDetrForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
>>> model = LwDetrForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]
```

## LwDetrViTBackbone[[transformers.LwDetrViTBackbone]]

#### transformers.LwDetrViTBackbone[[transformers.LwDetrViTBackbone]]

```python
transformers.LwDetrViTBackbone(config: LwDetrViTConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L342)

**Parámetros:**

config ([LwDetrViTConfig](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrViTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El backbone de Lw Detr.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.LwDetrViTBackbone.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L356)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [DeformableDetrImageProcessor](/docs/transformers/main/es/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Consulte [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [DeformableDetrImageProcessor](/docs/transformers/main/es/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) para procesar las imágenes).

**Devuelve:** `BackboneOutput` o `tuple(torch.Tensor)`

Un `BackboneOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([LwDetrConfig](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrConfig)) y las entradas.

El método forward de [LwDetrViTBackbone](/docs/transformers/main/es/model_doc/lw_detr#transformers.LwDetrViTBackbone) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **feature_maps** (`tuple(torch.Tensor)` de forma `(batch_size, num_channels, height, width)`) -- Mapas de características de las etapas.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)` o `(batch_size, num_channels, height, width)`, dependiendo del backbone.

  Estados ocultos del modelo en la salida de cada etapa más las salidas de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Solo aplicable si el backbone utiliza atención.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

```python
>>> from transformers import LwDetrViTConfig, LwDetrViTBackbone
>>> import torch

>>> config = LwDetrViTConfig()
>>> model = LwDetrViTBackbone(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 768, 14, 14]
```