Preprocesamiento acelerado por GPU con NVIDIA DALI#

Al implementar modelos Ultralytics YOLO en producción, el preprocesamiento suele convertirse en el cuello de botella. Aunque TensorRT puede ejecutar la inferencia del modelo en tan solo unos milisegundos, el preprocesamiento en CPU (cambio de tamaño, relleno y normalización) puede tardar entre 2 y 10 ms por imagen, especialmente con resoluciones altas. NVIDIA DALI (biblioteca de carga de datos) resuelve este problema al trasladar toda la cadena de preprocesamiento a la GPU.

Esta guía te explica cómo crear cadenas de procesamiento de DALI que reproduzcan exactamente el preprocesamiento letterbox de Ultralytics YOLO, integrarlas con model.predict(), procesar secuencias de vídeo e implementar la solución de extremo a extremo con Triton Inference Server.

Por qué usar DALI para el preprocesamiento de YOLO#

En una cadena de procesamiento de inferencia YOLO habitual, los pasos de preprocesamiento se ejecutan en la CPU:

1. Decodifica la imagen (JPEG/PNG)
2. Cambia el tamaño sin alterar la relación de aspecto
3. Ajusta el tamaño al objetivo (con letterbox)
4. Normaliza los valores de píxel de [0, 255] a [0, 1]
5. Convierte el formato de HWC a CHW

Con DALI, todas estas operaciones se ejecutan en la GPU, lo que elimina el cuello de botella de la CPU. Esto resulta especialmente útil cuando:

Requisitos previos#

Instala los paquetes necesarios:

pip install ultralytics
pip install --extra-index-url https://pypi.nvidia.com nvidia-dali-cuda130

Requisitos:

• GPU NVIDIA (capacidad de cálculo 5.0 o superior / Maxwell o posterior)
• CUDA 11.0+, 12.0+ o 13.0+
• Python 3.10-3.14
• Sistema operativo Linux

Cómo funciona el preprocesamiento de YOLO#

Antes de crear una canalización de DALI, conviene entender exactamente qué hace Ultralytics durante el preprocesamiento. La clase clave es LetterBox en ultralytics/data/augment.py:

from ultralytics.data.augment import LetterBox

letterbox = LetterBox(
    new_shape=(640, 640),  # Tamaño objetivo
    center=True,  # Centra la imagen (añade el mismo relleno a ambos lados)
    stride=32,  # Alineación con el stride
    padding_value=114,  # Relleno gris (114, 114, 114)
)

La canalización completa de preprocesamiento de ultralytics/engine/predictor.py realiza estos pasos:

La operación letterbox conserva la relación de aspecto mediante estos pasos:

1. Calcular la escala: r = min(target_h / h, target_w / w)
2. Redimensionar a (round(w * r), round(h * r))
3. Rellenar el espacio restante con gris (114) hasta alcanzar el tamaño objetivo
4. Centrar la imagen para distribuir el relleno por igual a ambos lados

Canalización de DALI para YOLO#

La canalización de DALI recomendada reproduce el comportamiento predeterminado LetterBox(center=True) de Ultralytics, que es el que utiliza la inferencia estándar de YOLO.

Canalización centrada (recomendada; coincide con LetterBox de Ultralytics)#

Esta versión reproduce exactamente el preprocesamiento predeterminado de Ultralytics con relleno centrado, y coincide con LetterBox(center=True):

from nvidia import dali
from nvidia.dali import fn, types

@dali.pipeline_def(batch_size=8, num_threads=4, device_id=0)
def yolo_dali_pipeline_centered(image_dir, target_size=640):
    """DALI pipeline replicating YOLO preprocessing with centered padding.

    Matches Ultralytics LetterBox(center=True) behavior exactly.
    """
    # Leer y decodificar imágenes en la GPU
    jpegs, _ = fn.readers.file(file_root=image_dir, random_shuffle=False, name="Reader")
    images = fn.decoders.image(jpegs, device="mixed", output_type=types.RGB)

    # Redimensionamiento que conserva la relación de aspecto
    resized = fn.resize(
        images,
        resize_x=target_size,
        resize_y=target_size,
        mode="not_larger",
        interp_type=types.INTERP_LINEAR,
        antialias=False,  # Iguala cv2.INTER_LINEAR (sin antialiasing)
    )

    # Relleno centrado mediante fn.crop con out_of_bounds_policy
    # Cuando el tamaño del recorte supera el de la imagen, fn.crop centra la imagen y añade relleno simétrico
    padded = fn.crop(
        resized,
        crop=(target_size, target_size),
        out_of_bounds_policy="pad",
        fill_values=114,  # Valor de relleno de YOLO
    )

    # Normalizar y convertir el formato
    output = fn.crop_mirror_normalize(
        padded,
        dtype=types.FLOAT,
        output_layout="CHW",
        mean=[0.0, 0.0, 0.0],
        std=[255.0, 255.0, 255.0],
    )
    return output

Ejecutar la canalización#

# Build and run the pipeline
pipe = yolo_dali_pipeline_centered(image_dir="/path/to/images", target_size=640)
pipe.build()

# Get a batch of preprocessed images
(output,) = pipe.run()

# Convert to numpy or PyTorch tensors
batch_np = output.as_cpu().as_array()  # Shape: (batch_size, 3, 640, 640)
print(f"Output shape: {batch_np.shape}, dtype: {batch_np.dtype}")
print(f"Value range: [{batch_np.min():.4f}, {batch_np.max():.4f}]")

Usar DALI con Predict de Ultralytics#

Puedes pasar directamente un tensor PyTorch preprocesado a model.predict(). Cuando se pasa un torch.Tensor, Ultralytics omite el preprocesamiento de la imagen (letterbox, BGR→RGB, HWC→CHW y normalización /255) y solo realiza la transferencia al dispositivo y la conversión del tipo de datos antes de enviarla al modelo.

Como Ultralytics no tiene acceso a las dimensiones de la imagen original en este caso, las coordenadas de las cajas de detección se devuelven en el espacio de letterbox de 640×640. Para volver a asignarlas a las coordenadas de la imagen original, usa scale_boxes, que aplica la misma lógica de redondeo exacta que LetterBox:

from ultralytics.utils.ops import scale_boxes

# cajas: tensor de forma (N, 4) en formato xyxy, con coordenadas en el espacio de letterbox de 640x640
# Escalar las cajas de las coordenadas de letterbox (640, 640) a las originales (orig_h, orig_w)
boxes = scale_boxes((640, 640), boxes, (orig_h, orig_w))

Esto se aplica a todas las rutas de preprocesamiento externo: entrada directa de tensores, flujos de vídeo y despliegue con Triton.

from nvidia.dali.plugin.pytorch import DALIGenericIterator

from ultralytics import YOLO

# Load model
model = YOLO("yolo26n.pt")

# Create DALI iterator
pipe = yolo_dali_pipeline_centered(image_dir="/path/to/images", target_size=640)
pipe.build()
dali_iter = DALIGenericIterator(pipe, ["images"], reader_name="Reader")

# Run inference with DALI-preprocessed tensors
for batch in dali_iter:
    images = batch[0]["images"]  # Already on GPU, shape (B, 3, 640, 640)
    results = model.predict(images, verbose=False)
    for result in results:
        print(f"Detected {len(result.boxes)} objects")

DALI con flujos de vídeo#

Para procesar vídeo en tiempo real, usa fn.external_source para alimentar fotogramas desde cualquier origen: OpenCV, GStreamer o bibliotecas de captura personalizadas:

from nvidia import dali
from nvidia.dali import fn, types

@dali.pipeline_def(batch_size=1, num_threads=4, device_id=0)
def yolo_video_pipeline(target_size=640):
    """DALI pipeline for processing video frames from external source."""
    # Origen externo para introducir fotogramas desde OpenCV, GStreamer, etc.
    frames = fn.external_source(device="cpu", name="input")
    frames = fn.reshape(frames, layout="HWC")

    # Mover a la GPU y preprocesar
    frames_gpu = frames.gpu()
    resized = fn.resize(
        frames_gpu,
        resize_x=target_size,
        resize_y=target_size,
        mode="not_larger",
        interp_type=types.INTERP_LINEAR,
        antialias=False,
    )
    padded = fn.crop(
        resized,
        crop=(target_size, target_size),
        out_of_bounds_policy="pad",
        fill_values=114,
    )
    output = fn.crop_mirror_normalize(
        padded,
        dtype=types.FLOAT,
        output_layout="CHW",
        mean=[0.0, 0.0, 0.0],
        std=[255.0, 255.0, 255.0],
    )
    return output

Servidor de inferencia Triton con DALI#

Para un despliegue de producción, combina el preprocesamiento de DALI con la inferencia de TensorRT en Triton Inference Server mediante un modelo de conjunto. Así se elimina por completo el preprocesamiento en la CPU: entran bytes JPEG sin procesar y salen detecciones, todo procesado en la GPU.

Estructura del repositorio del modelo#

model_repository/
├── dali_preprocessing/
│   ├── 1/
│   │   └── model.dali
│   └── config.pbtxt
├── yolo_trt/
│   ├── 1/
│   │   └── model.plan
│   └── config.pbtxt
└── ensemble_dali_yolo/
    ├── 1/                  # Empty directory (required by Triton)
    └── config.pbtxt

Paso 1: Crear la canalización de DALI#

Serializa la canalización de DALI para el backend de DALI de Triton:

from nvidia import dali
from nvidia.dali import fn, types

@dali.pipeline_def(batch_size=8, num_threads=4, device_id=0)
def triton_dali_pipeline():
    """DALI preprocessing pipeline for Triton deployment."""
    # Entrada: bytes de imagen sin procesar codificados procedentes de Triton
    images = fn.external_source(device="cpu", name="DALI_INPUT_0")
    images = fn.decoders.image(images, device="mixed", output_type=types.RGB)

    resized = fn.resize(
        images,
        resize_x=640,
        resize_y=640,
        mode="not_larger",
        interp_type=types.INTERP_LINEAR,
        antialias=False,
    )
    padded = fn.crop(
        resized,
        crop=(640, 640),
        out_of_bounds_policy="pad",
        fill_values=114,
    )
    output = fn.crop_mirror_normalize(
        padded,
        dtype=types.FLOAT,
        output_layout="CHW",
        mean=[0.0, 0.0, 0.0],
        std=[255.0, 255.0, 255.0],
    )
    return output

# Serializar la canalización en el repositorio del modelo
pipe = triton_dali_pipeline()
pipe.serialize(filename="model_repository/dali_preprocessing/1/model.dali")

Paso 2: Exportar YOLO a TensorRT#

from pathlib import Path

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
engine_path = model.export(
    format="engine", imgsz=640, quantize=16, batch=8, dynamic=True, nms=False
)  # Sin NMS (N, 300, 6); TensorRT >= 8.5

# Ultralytics antepone una cabecera de metadatos a los archivos .engine; elimínala para que Triton pueda cargar el plan TensorRT sin procesar
with open(engine_path, "rb") as f:
    meta_len = int.from_bytes(f.read(4), byteorder="little")  # longitud de la cabecera de metadatos JSON
    f.seek(4 + meta_len)
    plan = f.read()
Path("model_repository/yolo_trt/1").mkdir(parents=True, exist_ok=True)
Path("model_repository/yolo_trt/1/model.plan").write_bytes(plan)

Paso 3: Configurar Triton#

dali_preprocessing/config.pbtxt:

name: "dali_preprocessing"
backend: "dali"
max_batch_size: 8
input [
  {
    name: "DALI_INPUT_0"
    data_type: TYPE_UINT8
    dims: [ -1 ]
  }
]
output [
  {
    name: "DALI_OUTPUT_0"
    data_type: TYPE_FP32
    dims: [ 3, 640, 640 ]
  }
]

yolo_trt/config.pbtxt:

name: "yolo_trt"
platform: "tensorrt_plan"
max_batch_size: 8
input [
  {
    name: "images"
    data_type: TYPE_FP32
    dims: [ 3, 640, 640 ]
  }
]
output [
  {
    name: "output0"
    data_type: TYPE_FP32
    dims: [ 300, 6 ]
  }
]

ensemble_dali_yolo/config.pbtxt:

name: "ensemble_dali_yolo"
platform: "ensemble"
max_batch_size: 8
input [
  {
    name: "INPUT"
    data_type: TYPE_UINT8
    dims: [ -1 ]
  }
]
output [
  {
    name: "OUTPUT"
    data_type: TYPE_FP32
    dims: [ 300, 6 ]
  }
]
ensemble_scheduling {
  step [
    {
      model_name: "dali_preprocessing"
      model_version: -1
      input_map {
        key: "DALI_INPUT_0"
        value: "INPUT"
      }
      output_map {
        key: "DALI_OUTPUT_0"
        value: "preprocessed_image"
      }
    },
    {
      model_name: "yolo_trt"
      model_version: -1
      input_map {
        key: "images"
        value: "preprocessed_image"
      }
      output_map {
        key: "output0"
        value: "OUTPUT"
      }
    }
  ]
}

Paso 4: enviar solicitudes de inferencia#

import numpy as np
import tritonclient.http as httpclient

client = httpclient.InferenceServerClient(url="localhost:8000")

# Load image as raw bytes (JPEG/PNG encoded)
image_data = np.fromfile("image.jpg", dtype="uint8")
image_data = np.expand_dims(image_data, axis=0)  # Add batch dimension

# Create input
input_tensor = httpclient.InferInput("INPUT", image_data.shape, "UINT8")
input_tensor.set_data_from_numpy(image_data)

# Run inference through the ensemble
result = client.infer(model_name="ensemble_dali_yolo", inputs=[input_tensor])
detections = result.as_numpy("OUTPUT")  # Shape: (1, 300, 6) -> [x1, y1, x2, y2, conf, class_id]

# Filter by confidence (no NMS needed for the nms=False export)
detections = detections[0]  # First image
detections = detections[detections[:, 4] > 0.25]  # Confidence threshold
print(f"Detected {len(detections)} objects")

Tareas compatibles#

El preprocesamiento de DALI funciona con todas las tareas YOLO que usan la canalización estándar LetterBox:

Limitaciones#

• Solo Linux: DALI no es compatible con Windows ni macOS
• Se requiere una GPU NVIDIA: no hay alternativa solo con CPU
• Canalización estática: la estructura de la canalización se define durante la compilación y no se puede cambiar dinámicamente
• fn.pad solo rellena por la derecha y por abajo: usa fn.crop con out_of_bounds_policy="pad" para aplicar un relleno centrado
• Sin modo rect: las canalizaciones DALI generan resultados de tamaño fijo (p. ej., 640×640). El modo rect de auto=True, que genera resultados de tamaño variable (p. ej., 384×640), no es compatible. Ten en cuenta que, aunque TensorRT admite formas de entrada dinámicas, una canalización DALI de tamaño fijo se combina de forma natural con un motor de tamaño fijo para lograr el máximo rendimiento
• Memoria con varias instancias: usar instance_group con count > 1 en Triton puede provocar un uso elevado de memoria. Usa el grupo de instancias predeterminado para el modelo DALI

Preguntas frecuentes#