YOLO Vision 2026:

Ultralytics YOLO26 ile Triton Inference Server#

Triton Inference Server (daha önce TensorRT Inference Server olarak bilinirdi), NVIDIA tarafından geliştirilen açık kaynaklı bir yazılım çözümüdür. NVIDIA GPU'lar için optimize edilmiş bulut tabanlı bir çıkarım çözümü sunar. Triton, üretim ortamında AI modellerinin ölçeklenebilir bir şekilde dağıtılmasını basitleştirir. Ultralytics YOLO26 modelini Triton Inference Server ile entegre etmek, ölçeklenebilir ve yüksek performanslı deep learning çıkarım iş yükleri çalıştırmanıza olanak tanır. Bu kılavuz, entegrasyonu kurmak ve test etmek için adımlar sağlar.



Watch: Getting Started with NVIDIA Triton Inference Server.

Triton Inference Server nedir?#

Triton Inference Server, çeşitli yapay zeka modellerini üretim ortamında dağıtmak için tasarlanmıştır. PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT ve daha pek çoğu dahil olmak üzere geniş bir derin öğrenme ve machine learning çerçeve yelpazesini destekler. Başlıca kullanım alanları şunlardır:

  • Tek bir sunucu örneğinden birden fazla modele hizmet verme
  • Sunucuyu yeniden başlatmadan dinamik model yükleme ve kaldırma
  • Sonuç elde etmek için birden fazla modelin birlikte kullanılmasına olanak tanıyan topluluk (ensemble) çıkarımı
  • A/B testi ve kademeli güncellemeler için model sürümleme

Triton Inference Server'ın Temel Avantajları#

Triton Inference Server'ı Ultralytics YOLO26 ile birlikte kullanmak birkaç avantaj sağlar:

  • Otomatik gruplama (batching): Birden fazla yapay zeka isteğini işlemeden önce gruplandırarak gecikmeyi azaltır ve çıkarım hızını artırır
  • Kubernetes entegrasyonu: Bulut yerel tasarımı, yapay zeka uygulamalarını yönetmek ve ölçeklendirmek için Kubernetes ile sorunsuz çalışır
  • Donanıma özel optimizasyonlar: Maksimum performans için NVIDIA GPU'lardan tam olarak yararlanır
  • Çerçeve esnekliği: PyTorch, TensorFlow, ONNX, OpenVINO ve TensorRT dahil olmak üzere birden fazla AI çerçevesini destekler
  • Açık kaynak ve özelleştirilebilir: Belirli ihtiyaçlara uyacak şekilde değiştirilebilir, bu da çeşitli yapay zeka uygulamaları için esneklik sağlar

Ön koşullar#

Devam etmeden önce aşağıdaki ön koşullara sahip olduğundan emin ol:

  • Bilgisayarınızda Docker (>= 28.2.0, CDI GPU erişimi için NVIDIA Container Toolkit >= 1.18 ile) veya Podman kurulu olmalıdır
  • ultralytics paketini kur: 
    pip install ultralytics
  • tritonclient paketini kur: 
    pip install tritonclient[all]

Triton Inference Server Kurulumu#

Ultralytics YOLO26 modelini ONNX formatına aktarmak, Triton model havuzunu oluşturmak ve Triton Inference Server'ı başlatmak için bu tam kurulum bloğunu çalıştır:

Not

Kapsayıcı motorunu seçmek için betikteki runtime anahtarını kullan:

  • Docker için runtime = "docker" ayarla
  • Podman için runtime = "podman" ayarla
import contextlib
import subprocess
import time
from pathlib import Path

from tritonclient.http import InferenceServerClient

from ultralytics import YOLO

runtime = "docker"  # set to "podman" to use Podman

# 1) Exporting YOLO26 to ONNX Format

# Load a model
model = YOLO("yolo26n.pt")  # load an official model

# Retrieve metadata during export. Metadata needs to be added to config.pbtxt. See next section.
metadata = []

def export_cb(exporter):
    metadata.append(exporter.metadata)

model.add_callback("on_export_end", export_cb)

# Export the model
onnx_file = model.export(format="onnx", dynamic=True)

# 2) Setting Up Triton Model Repository

# Define paths
model_name = "yolo"
triton_repo_path = Path("tmp") / "triton_repo"
triton_model_path = triton_repo_path / model_name

# Create directories
(triton_model_path / "1").mkdir(parents=True, exist_ok=True)

# Move ONNX model to Triton Model path
Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")

# Create config file
(triton_model_path / "config.pbtxt").touch()

data = """
# Add metadata
parameters {
  key: "metadata"
  value {
    string_value: "%s"
  }
}

# Enable TensorRT acceleration (requires a GPU and TensorRT-enabled Triton; remove this block for CPU-only serving)
# The first run will be slow due to TensorRT engine conversion
optimization {
  execution_accelerators {
    gpu_execution_accelerator {
      name: "tensorrt"
      parameters {
        key: "precision_mode"
        value: "FP16"
      }
      parameters {
        key: "max_workspace_size_bytes"
        value: "3221225472"
      }
      parameters {
        key: "trt_engine_cache_enable"
        value: "1"
      }
      parameters {
        key: "trt_engine_cache_path"
        value: "/models/yolo/1"
      }
    }
  }
}
""" % metadata[0]  # noqa

with open(triton_model_path / "config.pbtxt", "w") as f:
    f.write(data)

# 3) Running Triton Inference Server

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:26.02-py3"  # 16.17 GB (Compressed Size)

subprocess.call(f"{runtime} pull {tag}", shell=True)

# CDI GPU request works identically on Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all"

container_name = "triton_server"

# Note: The :z flag on the volume mount is necessary for systems with SELinux (like Fedora/RHEL)
subprocess.call(
    f"{runtime} run -d --rm --name {container_name} {gpu_flags} -v {triton_repo_path.absolute()}:/models:z -p 8000:8000 {tag} tritonserver --model-repository=/models",
    shell=True,
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="127.0.0.1:8000", verbose=False, ssl=False)

# Wait until model is ready
for _ in range(10):
    with contextlib.suppress(Exception):
        assert triton_client.is_model_ready(model_name)
        break
    time.sleep(1)

Çıkarımı Çalıştırma#

Triton Server modelini kullanarak çıkarımı çalıştır:

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://127.0.0.1:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg")

Kapsayıcıyı temizle:

import subprocess

runtime = "docker"  # set to "podman" to use Podman
container_name = "triton_server"  # Kill the named container
subprocess.call(f"{runtime} kill {container_name}", shell=True)

TensorRT Optimizasyonu (İsteğe bağlı)#

Daha da yüksek performans için Triton Inference Server ile TensorRT kullanabilirsin. TensorRT, çıkarım hızını önemli ölçüde artırabilen, özellikle NVIDIA GPU'lar için oluşturulmuş yüksek performanslı bir derin öğrenme optimize edicisidir.

Triton ile TensorRT kullanmanın başlıca avantajları şunlardır:

  • Optimize edilmemiş modellere kıyasla 36 kata kadar daha hızlı çıkarım
  • Maksimum GPU kullanımı için donanıma özel optimizasyonlar
  • Doğruluğu korurken düşük hassasiyetli formatlar (INT8, FP16) desteği
  • Hesaplama yükünü azaltmak için katman birleştirme

TensorRT'yi doğrudan kullanmak için Ultralytics YOLO26 modelini TensorRT formatına aktarabilirsin:

from ultralytics import YOLO

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

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo26n.engine'

TensorRT optimizasyonu hakkında daha fazla bilgi için TensorRT integration guide kılavuzuna göz at.

Ölçeklenebilir ve yüksek performanslı çıkarım için Ultralytics YOLO26 modellerini artık Triton Inference Server üzerinde dağıtabilir ve çalıştırabilirsin. Daha fazla detay için official Triton documentation belgesine göz at veya yardım için Ultralytics community topluluğuna sor.

SSS#

Ultralytics YOLO26'yı NVIDIA Triton Inference Server ile nasıl kurarım?#

Ultralytics YOLO26 modelini NVIDIA Triton Inference Server ile kurmak birkaç önemli adım içerir:

  1. YOLO26'yı ONNX formatına dışa aktar:

    from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model

# Export the model to ONNX format
onnx_file = model.export(format="onnx", dynamic=True)

  2. Triton Model Deposunu kur:

    from pathlib import Path

# Define paths
model_name = "yolo"
triton_repo_path = Path("tmp") / "triton_repo"
triton_model_path = triton_repo_path / model_name

# Create directories
(triton_model_path / "1").mkdir(parents=True, exist_ok=True)
Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")
(triton_model_path / "config.pbtxt").touch()

  3. Triton Sunucusunu çalıştır:

    import contextlib
import subprocess
import time

from tritonclient.http import InferenceServerClient

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:26.02-py3"

runtime = "docker"  # set to "podman" to use Podman
subprocess.call(f"{runtime} pull {tag}", shell=True)

# CDI GPU request works identically on Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all"

container_name = "triton_server"
subprocess.call(
    f"{runtime} run -d --rm --name {container_name} {gpu_flags} -v {triton_repo_path.absolute()}:/models:z -p 8000:8000 {tag} tritonserver --model-repository=/models",
    shell=True,
)

triton_client = InferenceServerClient(url="127.0.0.1:8000", verbose=False, ssl=False)

for _ in range(10):
    with contextlib.suppress(Exception):
        assert triton_client.is_model_ready(model_name)
        break
    time.sleep(1)

Bu kurulum, yüksek performanslı AI modeli çıkarımı için Ultralytics YOLO26 modellerini Triton Inference Server üzerinde ölçekli bir şekilde verimli bir şekilde dağıtmana yardımcı olabilir.

Ultralytics YOLO26'yı NVIDIA Triton Inference Server ile kullanmak ne gibi faydalar sağlar?#

Ultralytics YOLO26 modelini NVIDIA Triton Inference Server ile entegre etmek birkaç avantaj sağlar:

  • Ölçeklenebilir Yapay Zeka Çıkarımı: Triton, tek bir sunucu örneğinden birden fazla modele hizmet vermeyi sağlar ve dinamik model yükleme ve kaldırmayı destekleyerek çeşitli yapay zeka iş yükleri için oldukça ölçeklenebilir hale getirir.
  • Yüksek Performans: NVIDIA GPU'lar için optimize edilmiş Triton Inference Server, object detection gibi gerçek zamanlı uygulamalar için mükemmel olan yüksek hızlı çıkarım operasyonları sağlar.
  • Topluluk ve Model Sürümleme: Triton'un topluluk (ensemble) modu, sonuçları iyileştirmek için birden fazla modelin birleştirilmesini sağlar ve model sürümlemesi, A/B testi ve kademeli güncellemeleri destekler.
  • Otomatik Gruplama (Batching): Triton, birden fazla çıkarım isteğini otomatik olarak gruplandırarak verimi önemli ölçüde artırır ve gecikmeyi azaltır.
  • Basitleştirilmiş Dağıtım: Yapay zeka iş akışlarının tüm sistem revizyonlarına gerek kalmadan kademeli olarak optimize edilmesi, verimli bir şekilde ölçeklendirmeyi kolaylaştırır.

Ultralytics YOLO26 modelini Triton ile kurma ve çalıştırma hakkında ayrıntılı talimatlar için Setting Up Triton Inference Server ve Running Inference bölümlerine göz at.

Neden Triton Inference Server kullanmadan önce YOLO26 modelimi ONNX formatına dışa aktarmalıyım?#

NVIDIA Triton Inference Server üzerinde dağıtmadan önce Ultralytics YOLO26 modelin için ONNX (Open Neural Network Exchange) formatını kullanmak çeşitli önemli avantajlar sunar:

  • Birlikte Çalışabilirlik: ONNX formatı, farklı derin öğrenme çerçeveleri (PyTorch, TensorFlow gibi) arasında aktarımı destekleyerek daha geniş bir uyumluluk sağlar.
  • Optimizasyon: Triton dahil birçok dağıtım ortamı, ONNX için optimize edilmiştir; bu da daha hızlı çıkarım ve daha iyi performans sağlar.
  • Dağıtım Kolaylığı: ONNX, çerçeveler ve platformlar arasında geniş çapta desteklenir ve çeşitli işletim sistemleri ile donanım yapılandırmalarında dağıtım sürecini basitleştirir.
  • Çerçeve Bağımsızlığı: ONNX'e dönüştürüldüğünde, modelin artık orijinal çerçevesine bağlı değildir, bu da onu daha taşınabilir kılar.
  • Standardizasyon: ONNX, farklı yapay zeka çerçeveleri arasındaki uyumluluk sorunlarını aşmaya yardımcı olan standartlaştırılmış bir temsil sağlar.

Modelini dışa aktarmak için şunu kullan:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
onnx_file = model.export(format="onnx", dynamic=True)

İşlemi tamamlamak için ONNX integration guide içindeki adımları takip edebilirsin.

Triton Inference Server üzerinde Ultralytics YOLO26 modelini kullanarak çıkarım çalıştırabilir miyim?#

Evet, Ultralytics YOLO26 modelini kullanarak NVIDIA Triton Inference Server üzerinde çıkarım çalıştırabilirsin. Modelin Triton Model Repository içinde ayarlandıktan ve sunucu çalışır duruma geldikten sonra, modelini yükleyebilir ve şu şekilde çıkarım çalıştırabilirsin:

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://127.0.0.1:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg")

Bu yaklaşım, tanıdık Ultralytics YOLO arayüzünü kullanırken Triton'un optimizasyonlarından yararlanmanı sağlar.

Ultralytics YOLO26, dağıtım için TensorFlow ve PyTorch modelleri ile nasıl karşılaştırılır?#

Ultralytics YOLO26, dağıtım açısından TensorFlow ve PyTorch modellerine kıyasla birkaç benzersiz avantaj sunar:

  • Gerçek Zamanlı Performans: Gerçek zamanlı nesne tespiti görevleri için optimize edilmiş olan Ultralytics YOLO26, en son teknoloji ürünü accuracy ve hız sunarak canlı video analitiği gerektiren uygulamalar için ideal hale gelir.
  • Kullanım Kolaylığı: Ultralytics YOLO26, Triton Inference Server ile sorunsuz bir şekilde bütünleşir ve çeşitli dışa aktarım formatlarını (ONNX, TensorRT) destekleyerek farklı dağıtım senaryoları için esneklik sağlar.
  • Gelişmiş Özellikler: Ultralytics YOLO26, ölçeklenebilir ve güvenilir AI dağıtımları için çok önemli olan dinamik model yükleme, model sürümleme ve topluluk çıkarımı gibi özellikler içerir.
  • Basitleştirilmiş API: Ultralytics API, farklı dağıtım hedefleri arasında tutarlı bir arayüz sunarak öğrenme eğrisini ve geliştirme süresini azaltır.
  • Uç (Edge) Optimizasyonu: Ultralytics YOLO26 modelleri, kaynak kısıtlı cihazlarda bile mükemmel performans sunarak uç dağıtımlar göz önünde bulundurularak tasarlanmıştır.

Daha fazla detay için model export guide içindeki dağıtım seçeneklerini karşılaştır.

Katkıda Bulunanlar
GLglenn-jocher19Y-Y-T-G4RAraimbekovm2ONonuralpszr2LEleonnil1

Yorumlar