İçeriğe geç

Ultralytics YOLO26 ile Triton Çıkarım Sunucusu

Triton Server (eski adıyla TensorRT Server), NVIDIA tarafından geliştirilen açık kaynaklı bir yazılım çözümüdür. NVIDIA için optimize edilmiş bir bulut tabanlı çıkarım çözümü sunar. Triton , üretim ortamında yapay zeka modellerinin büyük ölçekte devreye alınmasını Triton . Ultralytics Triton Server ile entegre etmek, ölçeklenebilir ve yüksek performanslı derin öğrenme çıkarım iş yüklerini devreye almanızı sağlar. Bu kılavuz, entegrasyonu kurmak ve test etmek için gerekli adımları açıklamaktadır.



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

Triton Inference Server nedir?

Triton Server, çeşitli yapay zeka modellerini üretim ortamında devreye almak üzere tasarlanmıştır. Aşağıdakiler dahil olmak üzere çok çeşitli derin öğrenme ve makine öğrenimi çerçevelerini destekler: PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT ve daha pek çok diğerleri. 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ı

Triton Server'ı Ultralytics ile birlikte kullanmak birçok avantaj 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: Aşağıdakiler dahil olmak üzere birçok yapay zeka çerçevesini destekler PyTorch, TensorFlow, ONNX, OpenVINO ve TensorRT
  • 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:

  • Bilgisayarınızda Docker veya Podman yüklü
  • Kurulum ultralytics: 
    pip install ultralytics
  • Kurulum tritonclient: 
    pip install tritonclient[all]

Triton Sunucusunu Kurma

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

Not

Şunu kullanın: runtime Konteyner motorunuzu seçmek için komut dosyasında şu değişikliği yapın:

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

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

Kullanımının başlıca avantajları TensorRT ile birlikte Triton :

  • 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 kullanmak için Ultralytics modelinizi TensorRT 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 modellerini Triton Server üzerinde verimli bir şekilde devreye alabilir ve çalıştırabilirsiniz; böylece derin öğrenme çıkarım görevleri için ölçeklenebilir ve yüksek performanslı bir çözüm elde edersiniz. Herhangi bir sorunla karşılaşırsanız veya başka sorularınız olursa, resmi Triton bakabilir veya destek almak için Ultralytics başvurabilirsiniz.

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ımları için Triton Server üzerinde Ultralytics modellerini büyük ölçekte verimli bir şekilde devreye almanıza yardımcı olabilir.

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

Ultralytics NVIDIA Triton Server ile entegre etmek birçok avantaj sağlar:

  • Ö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.

Ultralytics Triton ile kurma ve çalıştırma konusunda ayrıntılı talimatlar için, Triton Sunucusunu Kurma ve Çıkarım İşlemini Çalıştırma bölümüne bakın.

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

Ultralytics modelinizi NVIDIA Triton Server'da kullanıma sunmadan önce ONNX Open Neural Network Exchange) formatını kullanmanın birçok önemli avantajı vardır:

  • 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, NVIDIA Triton Server üzerinde Ultralytics modelini kullanarak çıkarım işlemi gerçekleştirebilirsiniz. Modeliniz Triton Deposu'na eklendikten ve sunucu çalışır duruma geldikten sonra, modelinizi aşağıdaki şekilde yükleyip çıkarım işlemini gerçekleştirebilirsiniz:

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, alıştığınız Ultralytics YOLO kullanırken Triton optimizasyonlarından yararlanmanızı sağlar.

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 , en üst düzeyde doğruluk ve hız sunarak canlı video analizi gerektiren uygulamalar için ideal bir çözümdür.
  • Kullanım Kolaylığı: Ultralytics , Triton Server ile sorunsuz bir şekilde entegre olur ve çeşitli dışa aktarım formatlarını destekler (ONNX, TensorRT) destekleyerek çeşitli dağıtım senaryoları için esneklik sağlar.
  • Gelişmiş Özellikler: Ultralytics , ölçeklenebilir ve güvenilir yapay zeka dağıtımları için hayati önem taşıyan dinamik model yükleme, model sürümleme ve toplu çıkarım gibi özelliklere 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ç Nokta Optimizasyonu: Ultralytics modelleri, uç noktaya 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 ✏️ 5 gün önce güncellendi
glenn-jocherY-T-GonuralpszrUltralyticsAssistantleonnil

Yorumlar