Preprocesamiento acelerado por GPU con NVIDIA DALI#

Al desplegar modelos de Ultralytics YOLO en producción, el preprocesamiento suele convertirse en el cuello de botella. Aunque TensorRT puede ejecutar la inferencia del modelo en apenas unos milisegundos, el preprocesamiento basado 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.

En esta guía aprenderás a crear cadenas de procesamiento de DALI que replican exactamente el preprocesamiento de Ultralytics YOLO, a integrarlas con model.predict(), a procesar flujos de vídeo y a realizar un despliegue integral con Triton Inference Server.

Por qué usar DALI para el preprocesamiento de YOLO#

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

1. Decodificar la imagen (JPEG/PNG)
2. Cambiar el tamaño conservando la relación de aspecto
3. Añadir relleno hasta alcanzar el tamaño objetivo (letterbox)
4. Normalizar los valores de píxel de [0, 255] a [0, 1]
5. Convertir el formato de HWC a CHW

Con DALI, todas estas operaciones se ejecutan en la GPU y se 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 cadena de procesamiento 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,  # Centrar la imagen (añadir la misma cantidad de relleno a ambos lados)
    stride=32,  # Alineación de paso
    padding_value=114,  # Relleno gris (114, 114, 114)
)

La cadena 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. Cambiar el tamaño a (round(w * r), round(h * r))
3. Rellenar el espacio restante de gris (114) para alcanzar el tamaño objetivo
4. Centrar la imagen para distribuir el relleno por igual a ambos lados

Cadena de procesamiento de DALI para YOLO#

La cadena de procesamiento de DALI recomendada replica el comportamiento predeterminado de LetterBox(center=True) de Ultralytics, que es el que se usa en la inferencia estándar de YOLO.

Cadena centrada (recomendada; coincide con LetterBox de Ultralytics)#

Esta versión replica exactamente el preprocesamiento predeterminado de Ultralytics con relleno centrado, que 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)

    # Cambiar el tamaño conservando 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,  # Coincidir con cv2.INTER_LINEAR (sin antialiasing)
    )

    # Relleno centrado con fn.crop y out_of_bounds_policy
    # Cuando el tamaño del recorte es mayor que 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 cadena de procesamiento#

# 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 a model.predict() un tensor de [PyTorch](https://ultralytics-translation-0.invalid preprocesado. Cuando se pasa un torch.Tensor, Ultralytics omite el preprocesamiento de imágenes (letterbox, BGR→RGB, HWC→CHW y normalización /255) y solo transfiere el dispositivo y convierte el tipo de datos antes de enviar el tensor al modelo.

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

from ultralytics.utils.ops import scale_boxes

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

Esto se aplica a todas las vías de preprocesamiento externo: entrada directa de tensores, flujos de vídeo y despliegue de 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 proporcionar fotogramas desde cualquier fuente: 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."""
    # Fuente externa para proporcionar fotogramas desde OpenCV, GStreamer, etc.
    frames = fn.external_source(device="cpu", name="input")
    frames = fn.reshape(frames, layout="HWC")

    # Transferir 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

Triton Inference Server con DALI#

Para el despliegue en 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, con todo el procesamiento realizado en la GPU.

Estructura del repositorio de modelos#

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: Crea la canalización de DALI#

Serializa la canalización de DALI para el backend 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 codificada sin procesar 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

# Serializa la canalización en el repositorio de modelos
pipe = triton_dali_pipeline()
pipe.serialize(filename="model_repository/dali_preprocessing/1/model.dali")

Paso 2: Exporta 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 añade un encabezado de metadatos a los archivos .engine; quítalo 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 del encabezado 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: Configura 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: Envía 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 de 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 para CPU
• Canalización estática: la estructura de la canalización se define durante la compilación y no puede cambiar dinámicamente
• fn.pad solo aplica el relleno a la derecha y abajo: usa fn.crop con out_of_bounds_policy="pad" para centrar el relleno
• Sin modo rect: las canalizaciones de 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 de DALI de tamaño fijo se combina de forma natural con un motor de tamaño fijo para obtener 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#