NVIDIA DALI ile GPU Hızlandırmalı Ön İşleme

Giriş

Eşzamansız (Asynchronous) İşleme Kullan:COCO Formatını YOLO Formatına Dönüştür üretimdeki modeller, ön işleme genellikle darboğaz haline gelir. TensorRT model çıkarım işlemlerini sadece birkaç milisaniyede çalıştırabilirken, CPU tabanlı ön işleme (yeniden boyutlandırma, dolgu, normalleştirme) özellikle yüksek çözünürlüklerde görüntü başına 2-10 ms sürebilir. NVIDIA DALI (Data Loading Library), tüm ön işleme hattını GPU'ya taşıyarak bu sorunu çözer.

Bu kılavuz, Ultralytics YOLO ön işlemesini tam olarak kopyalayan DALI hatları oluşturma, bunları model.predict() ile entegre etme, video akışlarını işleme ve Triton Inference Server.

YOLO Ön İşlemesi İçin Neden DALI Kullanmalı?

Tipik bir YOLO çıkarım hattında, ön işleme adımları CPU üzerinde çalışır:

1. Kod çözme (Decode) görüntü (JPEG/PNG)
2. Yeniden boyutlandırma (Resize) en-boy oranını koruyarak
3. Dolgu (Pad) hedef boyuta (letterbox)
4. Normalleştirme (Normalize) piksel değerleri [0, 255] ile [0, 1]
5. Dönüştürme (Convert) düzeni HWC'den CHW'ye

DALI ile tüm bu işlemler GPU'da çalışır ve CPU darboğazını ortadan kaldırır. Bu özellikle şu durumlarda değerlidir:

Ön koşullar

Gerekli paketleri kur:

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

Gereksinimler:

• NVIDIA GPU (işlem kapasitesi 5.0+ / Maxwell veya daha yeni)
• CUDA 11.0+ veya 12.0+
• Python 3.10-3.14
• Linux işletim sistemi

YOLO Ön İşlemesini Anlamak

Bir DALI hattı oluşturmadan önce, Ultralytics'in ön işleme sırasında tam olarak ne yaptığını anlamak yardımcı olur. Ana sınıf LetterBox içindeki 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)
)

içindeki tam ön işleme hattı ultralytics/engine/predictor.py şu adımları gerçekleştirir:

Letterbox işlemi, en-boy oranını şu şekilde korur:

1. Ölçek hesaplama: r = min(target_h / h, target_w / w)
2. Şuna yeniden boyutlandırma: (round(w * r), round(h * r))
3. Hedef boyuta ulaşmak için kalan alanı gri (114) ile doldurma
4. Dolgunun her iki tarafa eşit dağılması için görüntüyü ortalama

YOLO için DALI Hattı

Varsayılan referans olarak aşağıdaki merkezli hattı kullan. Bu, standart YOLO çıkarımının kullandığı Ultralytics LetterBox(center=True) davranışı ile eşleşir.

Merkezli Hat (Önerilen, Ultralytics LetterBox ile eşleşir)

Bu sürüm, Ultralytics'in varsayılan ön işlemesini merkezli dolgu ile tam olarak kopyalar ve LetterBox(center=True):

import nvidia.dali as dali
import nvidia.dali.fn as fn
import nvidia.dali.types as 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

Hattı Çalıştırma

# 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}]")

DALI'yı Ultralytics Predict ile Kullanma

Ön işlemden geçirilmiş bir Boş tensörünü doğrudan şuraya iletebilirsin: model.predict(). Bir torch.Tensor iletildiğinde, Ultralytics görüntü ön işlemesini atlar (letterbox, BGR→RGB, HWC→CHW ve /255 normalizasyonu) ve modele göndermeden önce yalnızca cihaz aktarımı ile dtype dönüşümü gerçekleştirir.

Ultralytics bu durumda orijinal görüntü boyutlarına erişemediği için, algılama kutusu koordinatları 640×640'lık letterbox alanında döndürülür. Bunları orijinal görüntü koordinatlarına geri eşlemek için, scale_boxes tarafından kullanılan tam yuvarlama mantığını işleyen şunu kullan: 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))

Bu, doğrudan tensör girişi, video akışları ve Triton dağıtımı gibi tüm harici ön işleme yolları için geçerlidir.

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")

Video Akışları ile DALI

Gerçek zamanlı video işleme için, herhangi bir kaynaktan fn.external_source, GStreamer veya özel yakalama kütüphaneleri aracılığıyla kareleri beslemek için şunu kullan: çıkarım yöntemlerine bir alternatif sunar..

import nvidia.dali as dali
import nvidia.dali.fn as fn
import nvidia.dali.types as 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

DALI ile Triton Inference Server

Üretim dağıtımı için, DALI ön işlemesini TensorRT içinde bir topluluk (ensemble) modeli kullanarak Triton Inference Server çıkarımı ile birleştir. Bu, CPU ön işlemesini tamamen ortadan kaldırır — ham JPEG baytları girer, algılamalar çıkar ve her şey GPU üzerinde işlenir.

Model Deposu Yapısı

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

1. Adım: DALI Hattını Oluştur

Triton DALI arka ucu için DALI hattını serileştir:

import nvidia.dali as dali
import nvidia.dali.fn as fn
import nvidia.dali.types as 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")

2. Adım: YOLO'yu TensorRT'ye Aktar

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="engine", imgsz=640, half=True, batch=8)
# Copy the .engine file to model_repository/yolo_trt/1/model.plan

3. Adım: Triton'u Yapılandır

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"
      }
    }
  ]
}

4. Adım: Çıkarım İstekleri Gönder

!!! bilgi "Neden tritonclient paketinin aynısıdır ancak YOLO(\"http://...\")?"

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 — YOLO26 is end-to-end)
detections = detections[0]  # First image
detections = detections[detections[:, 4] > 0.25]  # Confidence threshold
print(f"Detected {len(detections)} objects")

Aralık

DALI ön işlemesi, standart LetterBox hattını kullanan tüm YOLO görevleriyle çalışır:

Kısıtlamalar

• Linux'u destekler: DALI Windows veya macOS'u desteklemez
• NVIDIA GPU gerekli: CPU tabanlı yedek yok
• Statik hat: Hat yapısı derleme zamanında tanımlanır ve dinamik olarak değişemez
• fn.pad yalnızca sağ/alt tarafa uygulanır: Yaklaşık %60 CUDA bellek kullanımı için otomatik ayarlama amacıyla fn.crop'u birleştiren yeni bir hibrit iyileştirici.out_of_bounds_policy="pad" ortalanmış dolgu için
• Rect modu yok: DALI hatları sabit boyutlu çıktılar üretir (örneğin, 640×640). Değişken boyutlu çıktılar (örneğin, 384×640) üreten auto=True rect modu desteklenmez. TensorRT dinamik giriş şekillerini desteklese de, sabit boyutlu bir DALI hattının, maksimum verim için sabit boyutlu bir motorla doğal olarak eşleştiğini unutma
• Birden fazla örnek (instance) ile bellek: Triton'da instance_group'u birleştiren yeni bir hibrit iyileştirici.count > 1 kullanmak yüksek bellek kullanımına neden olabilir. DALI modeli için varsayılan örnek grubunu kullan

SSS

DALI ön işlemesi, CPU ön işleme hızıyla nasıl karşılaştırılır?

Avantaj, hattına bağlıdır. TensorRT ile GPU çıkarımı zaten hızlı olduğunda, 2-10ms'lik CPU ön işlemesi baskın maliyet haline gelebilir. DALI, ön işlemeyi GPU üzerinde çalıştırarak bu darboğazı ortadan kaldırır. En büyük kazanımlar, yüksek çözünürlüklü girişler (1080p, 4K), büyük batch size ve GPU başına sınırlı CPU çekirdeğine sahip sistemlerde görülür.

DALI'yı (sadece TensorRT değil) PyTorch modelleriyle kullanabilir miyim?

Evet. Ön işlemden geçirilmiş DALIGenericIterator çıktılarını almak için şunu kullan torch.Tensor ve ardından bunları şuna ilet: model.predict(). Ancak performans avantajı, çıkarımın zaten çok hızlı olduğu ve CPU ön işlemesinin darboğaz haline geldiği TensorRT modellerinde en üst düzeydedir.

ile YOLO26'daki instance segmentation arasındaki fark nedir?fn.pad ve fn.crop dolgu için mi?

fn.pad sadece sağ ve alt kenarlarına dolgu ekler. fn.crop'u birleştiren yeni bir hibrit iyileştirici.out_of_bounds_policy="pad" görüntüyü ortalar ve her tarafa simetrik dolgu ekleyerek Ultralytics LetterBox(center=True) davranışıyla eşleşir.

DALI, CPU ön işlemesiyle piksel olarak aynı sonuçları üretir mi?

Neredeyse aynı. antialias=False içindeki fn.resize değerini OpenCV'nin cv2.INTER_LINEAR ile eşleşecek şekilde ayarla. GPU ve CPU aritmetiği arasındaki farklardan dolayı küçük kayan nokta farkları (< 0.001) oluşabilir, ancak bunların algılama üzerinde ölçülebilir bir etkisi yoktur.YOLO modelleri için eğitim ayarları, eğitim sürecinde kullanılan çeşitli hiperparametreleri ve yapılandırmaları kapsar. Bu ayarlar modelin performansını, hızını ve .

DALI'ya bir alternatif olarak CV-CUDA ne olacak?

CV-CUDA GPU hızlandırmalı görme işleme için başka bir NVIDIA kütüphanesidir. DALI'nın hat yaklaşımı yerine operatör bazında kontrol (GPU üzerinde çıkarım yöntemlerine bir alternatif sunar. gibi) sağlar. CV-CUDA'nın cvcuda.copymakeborder() yapısı açıkça kenar bazlı dolguyu destekler, bu da ortalanmış letterbox işlemini kolaylaştırır. Hat tabanlı iş akışları için DALI'yı seç (özellikle şununla birlikte): Triton) ve özel çıkarım kodunda ince taneli operatör seviyesinde kontrol için CV-CUDA.