# OmDet-Turbo

## Resumen

El modelo OmDet-Turbo fue propuesto en [Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head](https://huggingface.co/papers/2403.06892) por Tiancheng Zhao, Peng Liu, Xuan He, Lu Zhang, Kyusong Lee. OmDet-Turbo incorpora componentes de RT-DETR e introduce un módulo de fusión multimodal ágil para lograr capacidades de detección de objetos de vocabulario abierto en tiempo real, manteniendo al mismo tiempo una alta precisión. El modelo base alcanza un rendimiento de hasta 100.2 FPS y 53.4 AP en COCO zero-shot.

El resumen del artículo es el siguiente:

*Los detectores basados en transformers de extremo a extremo (DETR) han demostrado un rendimiento excepcional en tareas de detección de objetos tanto en conjuntos cerrados como en vocabulario abierto (OVD) mediante la integración de modalidades de lenguaje. Sin embargo, sus exigentes requisitos computacionales han obstaculizado su aplicación práctica en escenarios de detección de objetos en tiempo real (OD). En este artículo, analizamos las limitaciones de dos modelos líderes en el benchmark OVDEval, OmDet y Grounding-DINO, e introducimos OmDet-Turbo. Este nuevo modelo de OVD en tiempo real basado en transformers incorpora un módulo innovador de Efficient Fusion Head (EFH) diseñado para aliviar los cuellos de botella observados en OmDet y Grounding-DINO. Cabe destacar que OmDet-Turbo-Base alcanza 100,2 fotogramas por segundo (FPS) al aplicar técnicas de TensorRT y caché de lenguaje. Además, en escenarios zero-shot en los conjuntos de datos COCO y LVIS, OmDet-Turbo logra niveles de rendimiento casi equivalentes a los de los modelos supervisados más avanzados actuales. Asimismo, establece nuevos benchmarks de estado del arte en ODinW y OVDEval, con un AP de 30,1 y un NMS-AP de 26,86, respectivamente. La viabilidad de OmDet-Turbo en aplicaciones industriales se resalta por su rendimiento excepcional en conjuntos de datos de referencia y su velocidad de inferencia superior, lo que lo posiciona como una opción atractiva para tareas de detección de objetos en tiempo real.*

 Resumen de la arquitectura de OmDet-Turbo. Tomado del artículo original.

Este modelo fue aportado por [yonigozlan](https://huggingface.co/yonigozlan). El código original se puede encontrar [aquí](https://github.com/om-ai-lab/OmDet).

## Consejos de uso

Una propiedad única de OmDet-Turbo en comparación con otros modelos de detección de objetos sin ejemplos, como [Grounding DINO](grounding-dino), es la estructura desacoplada de clases y embeddings de prompt que permite la caché de embeddings de texto. Esto significa que el modelo requiere tanto clases como tarea como entradas, donde classes es una lista de objetos que queremos detectar y task es el texto con anclaje utilizado para guiar la detección de vocabulario abierto. Este enfoque limita el alcance de la detección de vocabulario abierto y hace que el proceso de decodificación sea más rápido.

[OmDetTurboProcessor](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) se utiliza para preparar el tripleto de clases, tarea e imagen. La entrada de la tarea es opcional y, si no se proporciona, se usa por defecto `"Detect [class1], [class2], [class3], ..."`. Para procesar los resultados del modelo, se puede utilizar `post_process_grounded_object_detection` de [OmDetTurboProcessor](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Cabe destacar que esta función recibe las clases de entrada, ya que, a diferencia de otros modelos de detección de objetos zero-shot, el desacoplamiento de las incrustaciones de clases y de tareas significa que no es necesario decodificar las incrustaciones de clases predichas en el paso de posprocesamiento, y las clases predichas pueden coincidir directamente con las proporcionadas.

## Ejemplo de uso

### Inferencia de una sola imagen

A continuación se muestra cómo cargar el modelo y preparar las entradas para realizar la detección de objetos sin ejemplos en una sola imagen:

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

from transformers import AutoProcessor, OmDetTurboForObjectDetection

processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
text_labels = ["cat", "remote"]
inputs = processor(image, text=text_labels, return_tensors="pt").to(model.device)

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

# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
    outputs,
    target_sizes=[(image.height, image.width)],
    text_labels=text_labels,
    threshold=0.3,
    nms_threshold=0.3,
)
result = results[0]
boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"]
for box, score, text_label in zip(boxes, scores, text_labels):
    box = [round(i, 2) for i in box.tolist()]
    print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}")
Detected remote with confidence 0.768 at location [39.89, 70.35, 176.74, 118.04]
Detected cat with confidence 0.72 at location [11.6, 54.19, 314.8, 473.95]
Detected remote with confidence 0.563 at location [333.38, 75.77, 370.7, 187.03]
Detected cat with confidence 0.552 at location [345.15, 23.95, 639.75, 371.67]
```

### Inferencia con múltiples imágenes

OmDet-Turbo puede realizar inferencia por lotes con múltiples imágenes, con soporte para diferentes prompts de texto y clases en el mismo lote:

```python
import torch
import requests
from io import BytesIO
from PIL import Image
from transformers import AutoProcessor, OmDetTurboForObjectDetection

processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")

url1 = "http://images.cocodataset.org/val2017/000000039769.jpg"
image1 = Image.open(BytesIO(requests.get(url1).content)).convert("RGB")
text_labels1 = ["cat", "remote"]
task1 = "Detect {}.".format(", ".join(text_labels1))

url2 = "http://images.cocodataset.org/train2017/000000257813.jpg"
image2 = Image.open(BytesIO(requests.get(url2).content)).convert("RGB")
text_labels2 = ["boat"]
task2 = "Detect everything that looks like a boat."

url3 = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"
image3 = Image.open(BytesIO(requests.get(url3).content)).convert("RGB")
text_labels3 = ["statue", "trees"]
task3 = "Focus on the foreground, detect statue and trees."

inputs = processor(
    images=[image1, image2, image3],
    text=[text_labels1, text_labels2, text_labels3],
    task=[task1, task2, task3],
    return_tensors="pt",
)

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

# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
    outputs,
    text_labels=[text_labels1, text_labels2, text_labels3],
    target_sizes=[(image.height, image.width) for image in [image1, image2, image3]],
    threshold=0.2,
    nms_threshold=0.3,
)

for i, result in enumerate(results):
    for score, text_label, box in zip(
        result["scores"], result["text_labels"], result["boxes"]
    ):
        box = [round(i, 1) for i in box.tolist()]
        print(
            f"Detected {text_label} with confidence "
            f"{round(score.item(), 2)} at location {box} in image {i}"
        )
Detected remote with confidence 0.77 at location [39.9, 70.4, 176.7, 118.0] in image 0
Detected cat with confidence 0.72 at location [11.6, 54.2, 314.8, 474.0] in image 0
Detected remote with confidence 0.56 at location [333.4, 75.8, 370.7, 187.0] in image 0
Detected cat with confidence 0.55 at location [345.2, 24.0, 639.8, 371.7] in image 0
Detected boat with confidence 0.32 at location [146.9, 219.8, 209.6, 250.7] in image 1
Detected boat with confidence 0.3 at location [319.1, 223.2, 403.2, 238.4] in image 1
Detected boat with confidence 0.27 at location [37.7, 220.3, 84.0, 235.9] in image 1
Detected boat with confidence 0.22 at location [407.9, 207.0, 441.7, 220.2] in image 1
Detected statue with confidence 0.73 at location [544.7, 210.2, 651.9, 502.8] in image 2
Detected trees with confidence 0.25 at location [3.9, 584.3, 391.4, 785.6] in image 2
Detected trees with confidence 0.25 at location [1.4, 621.2, 118.2, 787.8] in image 2
Detected statue with confidence 0.2 at location [428.1, 205.5, 767.3, 759.5] in image 2

```

## OmDetTurboConfig[[transformers.OmDetTurboConfig]]

#### transformers.OmDetTurboConfig[[transformers.OmDetTurboConfig]]

```python
transformers.OmDetTurboConfig(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, 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, is_encoder_decoder: bool = True, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, apply_layernorm_after_vision_backbone: bool = True, image_size: int | list[int] | tuple[int, int] = 640, disable_custom_kernels: bool = False, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, init_std: float = 0.02, text_projection_in_dim: int = 512, text_projection_out_dim: int = 512, task_encoder_hidden_dim: int = 1024, class_embed_dim: int = 512, class_distance_type: typing.Literal['cosine', 'dot'] = 'cosine', num_queries: int = 900, csp_activation: str = 'silu', conv_norm_activation: str = 'gelu', encoder_feedforward_activation: str = 'relu', encoder_feedforward_dropout: float | int = 0.0, encoder_dropout: float | int = 0.0, hidden_expansion: int = 1, encoder_hidden_dim: int = 256, vision_features_channels: list[int] | tuple[int, ...] = (256, 256, 256), encoder_in_channels: list[int] | tuple[int, ...] = (192, 384, 768), encoder_projection_indices: list[int] | tuple[int, ...] = (2,), encoder_attention_heads: int = 8, encoder_dim_feedforward: int = 2048, encoder_layers: int = 1, positional_encoding_temperature: int = 10000, num_feature_levels: int = 3, decoder_hidden_dim: int = 256, decoder_num_heads: int = 8, decoder_num_layers: int = 6, decoder_activation: str = 'relu', decoder_dim_feedforward: int = 2048, decoder_num_points: int = 4, decoder_dropout: float | int = 0.0, eval_size: int | None = None, learn_initial_query: bool = False, cache_size: int = 100)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/configuration_omdet_turbo.py#L30)

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto.

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

apply_layernorm_after_vision_backbone (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar la normalización de capas a los mapas de características de la salida del backbone de visión.

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

disable_custom_kernels (`bool`, *opcional*, valor predeterminado `False`) : Si se desactivan los núcleos personalizados.

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

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

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

text_projection_in_dim (`int`, *opcional*, valor predeterminado 512) : La dimensión de entrada para la proyección de texto.

text_projection_out_dim (`int`, *opcional*, valor predeterminado 512) : La dimensión de salida para la proyección de texto.

task_encoder_hidden_dim (`int`, *opcional*, valor predeterminado 1024) : La dimensión del feedforward para el codificador de tareas.

class_embed_dim (`int`, *opcional*, valor predeterminado 512) : La dimensión de las incrustaciones de clases.

class_distance_type (`str`, *opcional*, valor predeterminado `"cosine"`) : El tipo de distancia para comparar las clases predichas con las incrustaciones de las clases proyectadas. Puede ser `"cosine"` o `"dot"`.

num_queries (`int`, *opcional*, valor predeterminado 900) : El número de consultas.

csp_activation (`str`, *opcional*, valor predeterminado `"silu"`) : La función de activación de las redes Cross Stage Partial (CSP) del codificador.

conv_norm_activation (`str`, *opcional*, valor predeterminado `"gelu"`) : La función de activación de las capas ConvNormLayer del codificador.

encoder_feedforward_activation (`str`, *opcional*, valor predeterminado `"relu"`) : La función de activación para la red feedforward del codificador.

encoder_feedforward_dropout (`float`, *opcional*, valor predeterminado 0.0) : La tasa de dropout tras la activación de la red feedforward del codificador.

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

hidden_expansion (`int`, *opcional*, valor predeterminado 1) : La expansión oculta de las redes CSP en el codificador.

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

vision_features_channels (`tuple(int)`, *opcional*, valor predeterminado `[256, 256, 256]`) : Los canales de características visuales proyectadas que se utilizan como entradas para el decodificador.

encoder_in_channels (`List(int)`, *opcional*, valor predeterminado `[192, 384, 768]`) : Los canales de entrada para el codificador.

encoder_projection_indices (`List(int)`, *opcional*, valor predeterminado `[2]`) : Los índices de las características de entrada proyectadas por cada capa.

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

encoder_dim_feedforward (`int`, *opcional*, valor predeterminado 2048) : La dimensión del feedforward para el codificador.

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

positional_encoding_temperature (`int`, *opcional*, valor predeterminado 10000) : La temperatura de la codificación posicional en el codificador.

num_feature_levels (`int`, *opcional*, valor predeterminado 3) : El número de niveles de características para el módulo de atención deformable multiescala del decodificador.

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

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

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

decoder_activation (`str`, *opcional*, valor predeterminado `"relu"`) : La función de activación para el decodificador.

decoder_dim_feedforward (`int`, *opcional*, valor predeterminado 2048) : La dimensión del feedforward para el decodificador.

decoder_num_points (`int`, *opcional*, valor predeterminado 4) : El número de puntos muestreados en el módulo de atención deformable multiescala del decodificador.

decoder_dropout (`float`, *opcional*, valor predeterminado 0.0) : La tasa de dropout para el decodificador.

eval_size (`tuple[int, int]`, *opcional*) : Altura y anchura utilizadas para calcular la altura y anchura efectivas de los embeddings de posición después de tener en cuenta el stride (véase RTDetr).

learn_initial_query (`bool`, *opcional*, valor predeterminado `False`) : Si se debe aprender la consulta inicial.

cache_size (`int`, *opcional*, valor predeterminado: 100) : El tamaño de la caché para las cachés de clases y prompts.

Esta es la clase de configuración para almacenar la configuración de un Omdet TurboModel. Se utiliza para instanciar un modelo Omdet Turbo 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 [omlab/omdet-turbo-swin-tiny-hf](https://huggingface.co/omlab/omdet-turbo-swin-tiny-hf)

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 OmDetTurboConfig, OmDetTurboForObjectDetection

>>> # Initializing a OmDet-Turbo omlab/omdet-turbo-swin-tiny-hf style configuration
>>> configuration = OmDetTurboConfig()

>>> # Initializing a model (with random weights) from the omlab/omdet-turbo-swin-tiny-hf style configuration
>>> model = OmDetTurboForObjectDetection(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## OmDetTurboProcessor[[transformers.OmDetTurboProcessor]]

#### transformers.OmDetTurboProcessor[[transformers.OmDetTurboProcessor]]

```python
transformers.OmDetTurboProcessor(image_processor, tokenizer)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/processing_omdet_turbo.py#L179)

**Parámetros:**

image_processor (`DetrImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio.

tokenizer (`CLIPTokenizer`) : El tokenizador es una entrada obligatoria.

Construye un OmDetTurboProcessor que envuelve un procesador de imágenes y un tokenizador en un único procesador.

[OmDetTurboProcessor](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) ofrece todas las funcionalidades de [DetrImageProcessor](/docs/transformers/main/es/model_doc/detr#transformers.DetrImageProcessor) y [CLIPTokenizer](/docs/transformers/main/es/model_doc/clip#transformers.CLIPTokenizer). Consulte [~DetrImageProcessor](/docs/transformers/main/es/model_doc/detr#transformers.DetrImageProcessor) y [~CLIPTokenizer](/docs/transformers/main/es/model_doc/clip#transformers.CLIPTokenizer) para obtener más información.

#### __llamada__[[transformers.OmDetTurboProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: list[str] | list[list[str]] | None = None, task: str | list[str] | None = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/processing_omdet_turbo.py#L190)

**Parámetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagen para preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

text (`Union[list[str], list[list[str]]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

task (`str`, `list[str]`, `TextInput` o `PreTokenizedInput`, *opcional*) : La(s) descripción(es) de la tarea de detección a codificar. Si no se proporciona, se genera una descripción de tarea predeterminada a partir de la entrada `text` (p. ej., "Detect {text}."). Puede ser una sola cadena, una lista de cadenas (una por imagen) o una entrada pretokenizada. La descripción de la tarea guía al modelo sobre qué objetos detectar en las imágenes.

return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

**Devuelve:** `~feature_extraction_utils.BatchFeature`

- **data** (`dict`, *opcional*) -- Diccionario de listas/arrays/tensores devueltos por los métodos __call__/pad ('input_values', 'attention_mask', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.
- **skip_tensor_conversion** (`list[str]` o `set[str]`, *opcional*) -- Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especifica `tensor_type`.

#### post_process_grounded_object_detection[[transformers.OmDetTurboProcessor.post_process_grounded_object_detection]]

```python
post_process_grounded_object_detection(outputs: OmDetTurboObjectDetectionOutput, text_labels: list[str] | list[list[str]] | None = None, threshold: float = 0.3, nms_threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None, max_num_det: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/processing_omdet_turbo.py#L273)

**Parámetros:**

outputs (`OmDetTurboObjectDetectionOutput`) : Salidas crudas del modelo.

text_labels (Union[list[str], list[list[str]]], *opcional*) : Nombres de las clases de entrada. Si no se proporcionan, `text_labels` se establecerá en `None` en `outputs`.

threshold (float, valor predeterminado 0.3) : Solo devuelve detecciones con una puntuación de confianza que supere este umbral.

nms_threshold (float, valor predeterminado 0.5) : Umbral a utilizar para la supresión de máximos no máximos de las cajas. Valor en [0, 1].

target_sizes (`torch.Tensor` o `list[tuple[int, int]]`, *opcional*) : Tensor de forma `(batch_size, 2)` o lista de tuplas (`tuple[int, int]`) que contiene el tamaño objetivo `(height, width)` de cada imagen del lote. Si no se establece, las predicciones no se redimensionarán.

max_num_det (`int`, *opcional*) : El número máximo de detecciones a devolver.

**Devuelve:** `list[Dict]`

Una lista de diccionarios, donde cada diccionario contiene las puntuaciones, las clases y las cajas de una imagen del lote, tal como las predice el modelo.

Convierte la salida cruda de [OmDetTurboForObjectDetection](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) en cajas delimitadoras finales en el formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y) y obtiene la clase de texto asociada.

## OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

#### transformers.OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

```python
transformers.OmDetTurboForObjectDetection(config: OmDetTurboConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/modeling_omdet_turbo.py#L1464)

**Parámetros:**

config ([OmDetTurboConfig](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboConfig)) : 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 OmDetTurbo (constituido por un backbone de visión y un backbone de texto, y una arquitectura encoder-decoder) que genera bounding boxes y puntuaciones de clases 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.OmDetTurboForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, classes_input_ids: LongTensor, classes_attention_mask: LongTensor, tasks_input_ids: LongTensor, tasks_attention_mask: LongTensor, classes_structure: LongTensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/modeling_omdet_turbo.py#L1494)

**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 [DetrImageProcessor](/docs/transformers/main/es/model_doc/detr#transformers.DetrImageProcessor). Consulte [DetrImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([OmDetTurboProcessor](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) utiliza [DetrImageProcessor](/docs/transformers/main/es/model_doc/detr#transformers.DetrImageProcessor) para procesar las imágenes).

classes_input_ids (`torch.LongTensor` de forma `(total_classes (>= batch_size), sequence_length)`) : Índices de los tokens de la secuencia de clases de entrada en el vocabulario del modelo de lenguaje. Se pueden proporcionar varias clases para cada tarea, por lo que las clases tokenizadas se aplanan y la estructura de las clases se proporciona en el argumento `classes_structure`. Los índices se pueden obtener usando [OmDetTurboProcessor](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Consulte [OmDetTurboProcessor.__call__()](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

classes_attention_mask (`torch.BoolTensor` de forma `(total_classes (>= batch_size), num_classes, sequence_length)`) : Máscara de atención para las clases. Esta es una máscara binaria que indica qué tokens deben ser atendidos y cuáles no.

tasks_input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de tareas de entrada en el vocabulario del modelo de lenguaje. Los índices se pueden obtener usando [OmDetTurboProcessor](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Consulte [OmDetTurboProcessor.__call__()](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids)

tasks_attention_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)`) : Máscara de atención para las tareas. Esta es una máscara binaria que indica qué tokens deben ser atendidos y cuáles no.

classes_structure (`torch.LongTensor` de forma `(batch_size)`) : Estructura de las clases. Este tensor indica el número de clases para cada tarea.

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

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

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

Un `OmDetTurboObjectDetectionOutput` 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 ([OmDetTurboConfig](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboConfig)) y las entradas.

El método forward de [OmDetTurboForObjectDetection](/docs/transformers/main/es/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) 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`, *opcional*) -- El valor de la pérdida.
- **decoder_coord_logits** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Los logits de coordenadas predichos de los objetos.
- **decoder_class_logits** (`torch.Tensor` de forma `(batch_size, num_queries, num_classes)`) -- La clase predicha de los objetos.
- **init_reference_points** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Los puntos de referencia iniciales.
- **intermediate_reference_points** (`tuple[tuple[torch.Tensor]]`, *opcional*) -- Los puntos de referencia intermedios.
- **encoder_coord_logits** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Las coordenadas predichas de los objetos por el codificador.
- **encoder_class_logits** (`tuple[torch.Tensor]`, *opcional*) -- La clase predicha de los objetos por el codificador.
- **encoder_extracted_states** (`torch.Tensor`, *opcional*) -- Los estados extraídos de la Feature Pyramid Network (FPN) y la Path Aggregation Network (PAN) del codificador.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- 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)`. Estados ocultos del modelo en la salida de cada capa más las salidas de los embeddings iniciales.
- **decoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opcional*) -- Tupla de tuplas de `torch.Tensor` (una para la atención de cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención, atención cruzada y atención deformable multiescala.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de `torch.Tensor` (una para la salida de las 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 de las incrustaciones iniciales.
- **encoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opcional*) -- Tupla de tuplas de `torch.Tensor` (una para la atención de 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, atención cruzada y atención deformable multiescala.
- **classes_structure** (`torch.LongTensor`, *opcional*) -- El número de clases consultadas para cada imagen.

Ejemplos:

```python
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image

>>> from transformers import AutoProcessor, OmDetTurboForObjectDetection

>>> processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
>>> model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> classes = ["cat", "remote"]
>>> task = "Detect {}.".format(", ".join(classes))
>>> inputs = processor(image, text=classes, task=task, return_tensors="pt")

>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits)
>>> results = processor.post_process_grounded_object_detection(
...     outputs,
...     classes=classes,
...     target_sizes=[image.size[::-1]],
...     score_threshold=0.3,
...     nms_threshold=0.3,
>>> )[0]
>>> for score, class_name, box in zip(results["scores"], results["classes"], results["boxes"]):
...     box = [round(i, 1) for i in box.tolist()]
...     print(
...         f"Detected {class_name} with confidence "
...         f"{round(score.item(), 2)} at location {box}"
...     )
Detected remote with confidence 0.76 at location [39.9, 71.3, 176.5, 117.9]
Detected cat with confidence 0.72 at location [345.1, 22.5, 639.7, 371.9]
Detected cat with confidence 0.65 at location [12.7, 53.8, 315.5, 475.3]
Detected remote with confidence 0.57 at location [333.4, 75.6, 370.7, 187.0]
```