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 tan solo unos milisegundos, el preprocesamiento basado en CPU (redimensionado, 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 trasladando todo el flujo de preprocesamiento a la GPU.

Esta guía te muestra cómo crear pipelines de DALI que replican exactamente el preprocesamiento de Ultralytics YOLO, integrarlos con model.predict(), procesar flujos de vídeo y desplegar todo el proceso con Triton Inference Server.

Por qué usar DALI para el preprocesamiento de YOLO#

En un pipeline de inferencia de YOLO típico, los pasos de preprocesamiento se ejecutan en la CPU:

1. Decodificar la imagen (JPEG/PNG)
2. Redimensionar 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, eliminando 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 de NVIDIA (capacidad de cálculo 5.0 o superior / Maxwell o posterior)
• CUDA 11.0 o superior, 12.0 o superior o 13.0 o superior
• Python 3.10-3.14
• Sistema operativo Linux

Comprender el preprocesamiento de YOLO#

Antes de crear un pipeline 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),  # Target size
    center=True,  # Center the image (pad equally on both sides)
    stride=32,  # Stride alignment
    padding_value=114,  # Gray padding (114, 114, 114)
)

El pipeline de preprocesamiento completo de ultralytics/engine/predictor.py realiza estos pasos:

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

1. Cálculo de la escala: r = min(target_h / h, target_w / w)
2. Redimensionado a (round(w * r), round(h * r))
3. Relleno del espacio restante con gris (114) hasta alcanzar el tamaño objetivo
4. Centrado de la imagen para distribuir el relleno por igual a ambos lados

Pipeline de DALI para YOLO#

El pipeline de DALI recomendado replica el comportamiento predeterminado LetterBox(center=True) de Ultralytics, que es el que utiliza la inferencia estándar de YOLO.

Pipeline centrado (recomendado, coincide con LetterBox de Ultralytics)#

Esta versión replica exactamente el preprocesamiento predeterminado de Ultralytics con relleno centrado, coincidiendo 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.
    """
    # Read and decode images on 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)

    # Aspect-ratio-preserving resize
    resized = fn.resize(
        images,
        resize_x=target_size,
        resize_y=target_size,
        mode="not_larger",
        interp_type=types.INTERP_LINEAR,
        antialias=False,  # Match cv2.INTER_LINEAR (no antialiasing)
    )

    # Centered padding using fn.crop with out_of_bounds_policy
    # When crop size > image size, fn.crop centers the image and pads symmetrically
    padded = fn.crop(
        resized,
        crop=(target_size, target_size),
        out_of_bounds_policy="pad",
        fill_values=114,  # YOLO padding value
    )

    # Normalize and convert layout
    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

Ejecución del pipeline#

# 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 Ultralytics Predict#

Puedes pasar directamente un tensor de 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 enviarlo 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 letterbox de 640×640. Para volver a asignarlas a las coordenadas de la imagen original, usa scale_boxes, que gestiona la lógica exacta de redondeo utilizada por LetterBox:

from ultralytics.utils.ops import scale_boxes

# boxes: tensor of shape (N, 4) in xyxy format, in 640x640 letterboxed coords
# Scale boxes from letterboxed (640, 640) back to original (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 el procesamiento de vídeo en tiempo real, usa fn.external_source para alimentar los 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."""
    # External source for feeding frames from OpenCV, GStreamer, etc.
    frames = fn.external_source(device="cpu", name="input")
    frames = fn.reshape(frames, layout="HWC")

    # Move to GPU and preprocess
    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 ensemble. Esto elimina por completo el preprocesamiento en CPU: entran bytes JPEG sin procesar y salen detecciones, con todo el procesamiento realizado 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 el pipeline de DALI#

Serializa el pipeline 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."""
    # Input: raw encoded image bytes from 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

# Serialize pipeline to model repository
pipe = triton_dali_pipeline()
pipe.serialize(filename="model_repository/dali_preprocessing/1/model.dali")

Paso 2: exportar YOLO a TensorRT#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(
    format="engine", imgsz=640, quantize=16, batch=8, dynamic=True, nms=False
)  # NMS-free (N, 300, 6); TensorRT >= 8.5
# Copy the .engine file to model_repository/yolo_trt/1/model.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 de YOLO que utilizan el pipeline estándar LetterBox:

Limitaciones#

• Solo Linux: DALI no es compatible con Windows ni macOS
• Se requiere una GPU NVIDIA: No hay alternativa que use únicamente la CPU
• Pipeline estático: La estructura del pipeline se define durante la compilación y no puede cambiar dinámicamente
• fn.pad solo admite derecha/abajo: Usa fn.crop con out_of_bounds_policy="pad" para un relleno centrado
• Sin modo rect: Los pipelines de DALI generan salidas de tamaño fijo (por ejemplo, 640×640). El modo rect de auto=True, que genera salidas de tamaño variable (por ejemplo, 384×640), no es compatible. Ten en cuenta que, aunque TensorRT admite formas de entrada dinámicas, un pipeline de DALI de tamaño fijo se combina de forma natural con un motor de tamaño fijo para maximizar el 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#