İçeriğe geç

Ultralytics YOLO26 ile Triton Çıkarım Sunucusu

Triton Inference Server (önceden TensorRT Inference Server olarak bilinen), NVIDIA tarafından geliştirilen açık kaynaklı bir yazılım çözümüdür. NVIDIA GPU'ları için optimize edilmiş bir bulut çıkarım çözümü sunar. Triton, yapay zeka modellerinin üretimde büyük ölçekte dağıtımını basitleştirir. Ultralytics YOLO26'yı Triton Inference Server ile entegre etmek, ölçeklenebilir, yüksek performanslı derin öğrenme çıkarım iş yüklerini dağıtmanıza olanak tanır. Bu kılavuz, entegrasyonu kurmak ve test etmek için adımlar sunar.



İzle: NVIDIA Triton Çıkarım Sunucusu'nu Kullanmaya Başlama.

Triton Inference Server nedir?

Triton Inference Server, üretimde çeşitli yapay zeka modellerini dağıtmak için tasarlanmıştır. PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT ve diğerleri dahil olmak üzere çok çeşitli derin öğrenme ve makine öğrenimi çerçevelerini destekler. Başlıca kullanım alanları şunlardır:

  • Tek bir sunucu örneğinden birden fazla model sunma
  • Sunucuyu yeniden başlatmadan dinamik model yükleme ve kaldırma
  • Sonuçlara ulaşmak için birden fazla modelin birlikte kullanılmasına olanak tanıyan ensemble çıkarımı
  • A/B testi ve aşamalı güncellemeler için model versiyonlama

Triton Inference Server'ın Temel Faydaları

Ultralytics YOLO26 ile Triton Inference Server kullanmak çeşitli avantajlar sağlar:

  • Otomatik toplu işleme: 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 tabanlı tasarım, AI 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 çok yapay zeka çerçevesini destekler
  • Açık kaynaklı ve özelleştirilebilir: Belirli ihtiyaçlara uyacak şekilde değiştirilebilir, çeşitli yapay zeka uygulamaları için esneklik sağlar

Ön koşullar

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

  • Makinenizde Docker veya Podman kurulu olmalı
  • Kurulum ultralytics: 
    pip install ultralytics
  • Kurulum tritonclient: 
    pip install tritonclient[all]

Triton Inference Server Kurulumu

Ultralytics YOLO26'yı ONNX'e dışa aktarmak, Triton model deposunu oluşturmak ve Triton Inference Server'ı başlatmak için bu kurulum bloğunu çalıştırın:

Not

Şunu kullanın: runtime komut dosyasındaki anahtarı kullanarak kapsayıcı motorunuzu seçin:

  • Ayarla runtime = "docker" Docker için
  • Ayarla runtime = "podman" Podman için
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"
  }
}

# (Optional) Enable TensorRT for GPU inference
# 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)

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

Triton Server modelini kullanarak çıkarım yapın:

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ı temizleyin (runtime ve container_name yukarıdaki kurulum bloğunda tanımlanmıştır):

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 kullanabilirsiniz. TensorRT, çıkarım hızını önemli ölçüde artırabilen, NVIDIA GPU'lar için özel olarak oluşturulmuş yüksek performanslı bir derin öğrenme optimize edicisidir.

Triton ile TensorRT kullanmanın temel faydaları ş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 azaltılmış hassasiyet formatları (INT8, FP16) için destek
  • Hesaplama yükünü azaltmak için katman birleştirme

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

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ın.

Yukarıdaki adımları izleyerek, Ultralytics YOLO26 modellerini Triton Inference Server üzerinde verimli bir şekilde dağıtabilir ve çalıştırabilir, derin öğrenme çıkarım görevleri için ölçeklenebilir ve yüksek performanslı bir çözüm sağlayabilirsiniz. Herhangi bir sorunla karşılaşırsanız veya başka sorularınız olursa, resmi Triton belgelerine başvurabilir veya destek için Ultralytics topluluğuna ulaşabilirsiniz.

SSS

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

Ultralytics YOLO26'yı NVIDIA Triton Inference Server ile kurmak birkaç temel adım içerir:

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

    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 Deposu Kurun:

    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ğıtmanıza yardımcı olabilir.

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

Ultralytics YOLO26'yı NVIDIA Triton Inference Server ile entegre etmek çeşitli avantajlar sunar:

  • Ölçeklenebilir Yapay Zeka Çıkarımı: Triton, dinamik model yükleme ve boşaltmayı destekleyerek tek bir sunucu örneğinden birden çok modele hizmet verilmesine olanak tanır ve bu da onu çeşitli yapay zeka iş yükleri için son derece ölçeklenebilir hale getirir.
  • Yüksek Performans: NVIDIA GPU'lar için optimize edilmiş Triton Inference Server, nesne algılama gibi gerçek zamanlı uygulamalar için mükemmel olan yüksek hızlı çıkarım işlemleri sağlar.
  • Ensemble ve Model Sürümleme: Triton'un ensemble modu, sonuçları iyileştirmek için birden çok modeli birleştirmeyi sağlar ve model sürümlemesi, A/B testini ve aşamalı güncellemeleri destekler.
  • Otomatik Toplu İşleme: 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: Tam sistem revizyonları gerektirmeden yapay zeka iş akışlarının kademeli optimizasyonu, verimli bir şekilde ölçeklendirmeyi kolaylaştırır.

Triton ile Ultralytics YOLO26'yı kurma ve çalıştırma hakkında ayrıntılı talimatlar için Triton Inference Server Kurulumu ve Çıkarım Çalıştırma bölümlerine bakın.

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

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

  • Birlikte Çalışabilirlik: ONNX formatı, farklı derin öğrenme çerçeveleri (PyTorch, TensorFlow gibi) arasında aktarımı destekleyerek daha geniş uyumluluk sağlar.
  • Optimizasyon: Triton dahil olmak üzere birçok dağıtım ortamı, daha hızlı çıkarım ve daha iyi performans sağlayarak ONNX için optimizasyon yapar.
  • Dağıtım Kolaylığı: ONNX, çeşitli çerçeveler ve platformlar arasında yaygın olarak desteklenir ve çeşitli işletim sistemlerinde ve 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ükten sonra, modeliniz artık orijinal çerçevesine bağlı değildir ve bu da onu daha taşınabilir hale getirir.
  • Standardizasyon: ONNX, farklı yapay zeka çerçeveleri arasındaki uyumluluk sorunlarının üstesinden gelmeye yardımcı olan standartlaştırılmış bir temsil sağlar.

Modelinizi dışa aktarmak için şunu kullanın:

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ı izleyebilirsiniz.

Ultralytics YOLO26 modelini Triton Inference Server üzerinde çıkarım yapmak için kullanabilir miyim?

Evet, Ultralytics YOLO26 modelini NVIDIA Triton Inference Server üzerinde çıkarım yapmak için kullanabilirsiniz. Modeliniz Triton Model Repository'de kurulduktan ve sunucu çalışır duruma geldikten sonra, modelinizi aşağıdaki gibi yükleyebilir ve üzerinde çıkarım çalıştırabilirsiniz:

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ıza olanak tanır.

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

Ultralytics YOLO26, dağıtım için TensorFlow ve PyTorch modellerine kıyasla çeşitli benzersiz avantajlar sunar:

  • Gerçek Zamanlı Performans: Gerçek zamanlı nesne algılama görevleri için optimize edilmiş olan Ultralytics YOLO26, son teknoloji doğruluk ve hız sunarak, canlı video analizi 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, farklı dağıtım senaryoları için esneklik sağlar.
  • Gelişmiş Özellikler: Ultralytics YOLO26, dinamik model yükleme, model sürümleme ve toplu çıkarım gibi özellikler içerir; bunlar ölçeklenebilir ve güvenilir yapay zeka dağıtımları için kritik öneme sahiptir.
  • Basitleştirilmiş API: Ultralytics API, farklı dağıtım hedefleri arasında tutarlı bir arayüz sağlayarak öğrenme eğrisini ve geliştirme süresini azaltır.
  • Uç Cihaz Optimizasyonu: Ultralytics YOLO26 modelleri, uç cihaz dağıtımı göz önünde bulundurularak 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ın.



📅 2 yıl önce oluşturuldu ✏️ 18 gün önce güncellendi
glenn-jocherY-T-GonuralpszrUltralyticsAssistantleonnil

Yorumlar