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

Üretim ortamında Ultralytics YOLO modellerini dağıtırken ön işleme genellikle darboğaz hâline gelir. TensorRT model çıkarımını yalnızca birkaç milisaniyede gerçekleştirebilirken CPU tabanlı ön işleme (yeniden boyutlandırma, doldurma, normalleştirme), özellikle yüksek çözünürlüklerde görüntü başına 2-10 ms sürebilir. NVIDIA DALI (Veri Yükleme Kütüphanesi), tüm ön işleme işlem hattını GPU'ya taşıyarak bu sorunu çözer.

Bu kılavuzda, Ultralytics YOLO ön işlemesini birebir yineleyen DALI işlem hatlarının nasıl oluşturulacağı, bunların model.predict() ile nasıl entegre edileceği, video akışlarının nasıl işleneceği ve Triton Inference Server ile uçtan uca nasıl dağıtılacağı açıklanır.

YOLO Ön İşlemesi için DALI Neden Kullanılmalı?#

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

1. Görüntünün kodunu çöz (JPEG/PNG)
2. En-boy oranını koruyarak yeniden boyutlandır
3. Hedef boyuta doldur (letterbox)
4. Piksel değerlerini [0, 255] ile [0, 1] arasında normalleştir
5. Düzeni HWC'den CHW'ye dönüştür

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

Ön koşullar#

Gerekli paketleri yükle:

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

Gereksinimler:

• NVIDIA GPU (işlem yeteneği 5.0+ / Maxwell veya daha yenisi)
• CUDA 11.0+, 12.0+ veya 13.0+
• Python 3.10-3.14
• Linux işletim sistemi

YOLO Ön İşlemesini Anlamak#

Bir DALI işlem hattı oluşturmadan önce Ultralytics'in ön işleme sırasında tam olarak ne yaptığını anlamakta fayda var. Temel sınıf ultralytics/data/augment.py içindeki LetterBox sınıfıdır:

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

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

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

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

YOLO için DALI İşlem Hattı#

Önerilen DALI işlem hattı, standart YOLO çıkarımının kullandığı varsayılan Ultralytics LetterBox(center=True) davranışını yineler.

Ortalanmış İşlem Hattı (Önerilen, Ultralytics LetterBox ile eşleşir)#

Bu sürüm, ortalanmış doldurma kullanarak varsayılan Ultralytics ön işlemesini tam olarak yineler ve LetterBox(center=True) ile eşleşir:

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

İşlem Hattını Ç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'yi Ultralytics Predict ile Kullanma#

Ön işlenmiş bir PyTorch tensörünü doğrudan model.predict() öğesine aktarabilirsin. Bir torch.Tensor aktarıldığında Ultralytics görüntü ön işlemesini atlar (letterbox, BGR→RGB, HWC→CHW ve /255 normalleştirmesi) ve modele göndermeden önce yalnızca cihaz aktarımı ile veri türü dönüşümünü gerçekleştirir.

Ultralytics bu durumda özgün görüntü boyutlarına erişemediğinden algılama kutusu koordinatları 640×640 letterbox alanında döndürülür. Bunları özgün görüntü koordinatlarına eşlemek için LetterBox tarafından kullanılan tam yuvarlama mantığını uygulayan scale_boxes öğesini kullan:

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 durum tüm harici ön işleme yolları için geçerlidir — doğrudan tensör girdisi, video akışları ve Triton dağıtımı.

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 ile Video Akışları#

Gerçek zamanlı video işleme için kareleri herhangi bir kaynaktan beslemek üzere fn.external_source kullan — OpenCV, GStreamer veya özel yakalama kütüphaneleri:

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

DALI ile Triton Inference Server#

Üretim dağıtımı için DALI ön işlemesini Triton Inference Server içinde TensorRT çıkarımıyla bir topluluk modeli kullanarak birleştir. Böylece CPU ön işlemesi tamamen ortadan kalkar — ham JPEG baytları girer, algılamalar çıkar ve tüm işlemler GPU üzerinde gerçekleştirilir.

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

Adım: DALI İşlem Hattını Oluşturma#

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

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

Adım: YOLO'yu TensorRT'ye Aktarma#

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

Adım: Triton'u Yapılandırma#

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

Adım: Çıkarım İstekleri Gönderme#

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

Desteklenen Görevler#

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

Sınırlamalar#

• Yalnızca Linux: DALI, Windows veya macOS'u desteklemez
• NVIDIA GPU gereklidir: Yalnızca CPU kullanımı için geri dönüş seçeneği yoktur
• Statik işlem hattı: İşlem hattının yapısı derleme zamanında tanımlanır ve dinamik olarak değiştirilemez
• fn.pad yalnızca sağa alta dolgu ekler: Ortalanmış dolgu için out_of_bounds_policy="pad" ile birlikte fn.crop kullanın
• Rect modu yoktur: DALI işlem hatları sabit boyutlu çıktılar üretir (ör. 640×640). Değişken boyutlu çıktılar (ör. 384×640) üreten auto=True rect modu desteklenmez. TensorRT dinamik giriş şekillerini desteklese de maksimum aktarım hızı için sabit boyutlu bir DALI işlem hattının sabit boyutlu bir motorla doğal olarak eşleştiğini unutmayın
• Birden çok örnekle bellek kullanımı: Triton'da count > 1 ile instance_group kullanmak yüksek bellek kullanımına neden olabilir. DALI modeli için varsayılan örnek grubunu kullanın

SSS#