Meet YOLO26: next-gen vision AI.

Link to this sectionUltralytics YOLO26 ile Triton Inference Server#

Triton Inference Server (eski adıyla TensorRT Inference Server), 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, yapay zeka modellerinin üretim ortamında ölçekli bir şekilde dağıtımını basitleştirir. Ultralytics YOLO26 modelini Triton Inference Server ile entegre ederek ölçeklenebilir ve yüksek performanslı derin öğrenme çıkarım iş yükleri dağıtabilirsin. Bu kılavuz, entegrasyonu kurman ve test etmen için gereken adımları sunar.



Watch: Getting Started with NVIDIA Triton Inference Server.

Link to this sectionTriton Inference Server nedir?#

Triton Inference Server is designed to deploy a variety of AI models in production. It supports a wide range of deep learning and machine learning frameworks, including PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT and many others. Its primary use cases are:

  • 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

Link to this sectionTriton Inference Server'ın Temel Avantajları#

Triton Inference Server'ı Ultralytics YOLO26 ile 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 birçok yapay zeka ç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

Link to this sectionÖn koşullar#

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

  • Makinenizde yüklü Docker veya Podman
  • ultralytics paketini yükle: 
    pip install ultralytics
  • tritonclient paketini yükle: 
    pip install tritonclient[all]

Link to this sectionTriton Inference Server Kurulumu#

Ultralytics YOLO26 modelini ONNX formatına dışa aktarmak, Triton model deposunu 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)

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus 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)

Link to this sectionÇı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)

Link to this sectionTensorRT Optimizasyonu (İsteğe bağlı)#

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

Triton ile TensorRT kullanmanın temel 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 dışa 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 entegrasyon kılavuzuna bak.

Artık ölçeklenebilir ve yüksek performanslı çıkarım için Ultralytics YOLO26 modellerini Triton Inference Server üzerinde dağıtabilir ve çalıştırabilirsin. Daha fazla detay için resmi Triton belgelerine bakabilir veya yardım almak için Ultralytics topluluğuna danışabilirsin.

Link to this sectionSSS#

Link to this sectionUltralytics YOLO26'yı NVIDIA Triton Inference Server ile nasıl kurarım?#

Ultralytics YOLO26 modelini NVIDIA Triton Inference Server ile kurmak birkaç temel 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)

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus 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ı yapay zeka modeli çıkarımı için Ultralytics YOLO26 modellerini Triton Inference Server üzerinde ölçekli bir şekilde verimli bir şekilde dağıtmana yardımcı olabilir.

Link to this sectionUltralytics YOLO26'yı NVIDIA Triton Inference Server ile kullanmak ne gibi faydalar sağlar?#

Ultralytics YOLO26 modelini NVIDIA Triton Inference Server ile entegre etmek çeşitli avantajlar 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ş olan Triton Inference Server, nesne tespiti gibi gerçek zamanlı uygulamalar için mükemmel olan yüksek hızlı çıkarım işlemleri 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 kurup çalıştırma konusunda ayrıntılı talimatlar için Triton Inference Server Kurulumu ve Çıkarım Çalıştırma bölümlerine bakabilirsin.

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

Ultralytics YOLO26 modelin için NVIDIA Triton Inference Server üzerinde dağıtmadan önce ONNX (Open Neural Network Exchange) formatını kullanmanın birkaç önemli avantajı vardır:

  • 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 entegrasyon kılavuzundaki adımları takip edebilirsin.

Link to this sectionTriton Inference Server üzerinde Ultralytics YOLO26 modelini kullanarak çıkarım çalıştırabilir miyim?#

Evet, Ultralytics YOLO26 modelini NVIDIA Triton Inference Server üzerinde kullanarak çıkarım çalıştırabilirsin. Modelin Triton Model Deposunda kurulduğunda ve sunucu çalışır durumda olduğunda, modelini yükleyebilir ve çıkarımı şu şekilde ç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.

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

Ultralytics YOLO26, dağıtım için 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ş Ultralytics YOLO26, en son teknoloji doğruluk ve hız sunarak canlı video analitiği gerektiren uygulamalar için idealdir.
  • Kullanım Kolaylığı: Ultralytics YOLO26, Triton Inference Server ile sorunsuz bir şekilde entegre olur ve çeşitli dışa aktarma formatlarını (ONNX, TensorRT) destekleyerek çeşitli dağıtım senaryoları için esneklik sağlar.
  • Gelişmiş Özellikler: Ultralytics YOLO26, ölçeklenebilir ve güvenilir yapay zeka dağıtımları için kritik öneme sahip dinamik model yükleme, model sürümleme ve topluluk (ensemble) çı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ç Nokta Optimizasyonu: Ultralytics YOLO26 modelleri uç nokta dağıtımı düşünülerek tasarlanmıştır ve kaynak kısıtlı cihazlarda bile mükemmel performans sunar.

Daha fazla ayrıntı için model dışa aktarma kılavuzundaki dağıtım seçeneklerini karşılaştır.

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

Yorumlar