İçeriğe geç

Triton Ultralytics YOLO11 ile Çıkarım Sunucusu

The Triton Inference Server (formerly known as TensorRT Inference Server) is an open-source software solution developed by NVIDIA. It provides a cloud inference solution optimized for NVIDIA GPUs. Triton simplifies the deployment of AI models at scale in production. Integrating Ultralytics YOLO11 with Triton Inference Server allows you to deploy scalable, high-performance deep learning inference workloads. This guide provides steps to set up and test the integration.



İzle: NVIDIA Triton Inference Server ile Başlarken.

Triton Çıkarım Sunucusu 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 TensorFlow, PyTorch, ONNX Runtime, and many others. Its primary use cases are:

  • Tek bir sunucu örneğinden birden fazla model sunma.
  • Sunucu yeniden başlatılmadan dinamik model yükleme ve boşaltma.
  • Ensemble çıkarımı, sonuçlara ulaşmak için birden fazla modelin birlikte kullanılmasına izin verir.
  • A/B testi ve sürekli güncellemeler için model versiyonlama.

Ön Koşullar

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

  • Makinenizde Docker yüklü.
  • Kurulum tritonclient: 
    pip install tritonclient[all]

YOLO11'i ONNX Formatına Aktarma

Modeli Triton adresine yerleştirmeden önce ONNX formatına aktarılması gerekir. ONNX (Open Neural Network Exchange), modellerin farklı derin öğrenme çerçeveleri arasında aktarılmasını sağlayan bir formattır. Kullanın export fonksiyonundan YOLO Sınıf:

from ultralytics import YOLO

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

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

Triton Model Deposunun Kurulması

Triton Model Deposu, Triton adresinin modellere erişebileceği ve yükleyebileceği bir depolama yeridir.

  1. Gerekli dizin yapısını oluşturun:

    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)

  2. Dışa aktarılan ONNX modelini Triton deposuna taşıyın:

    from pathlib import Path

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

# (Optional) Enable TensorRT for GPU inference
# First run will be slow due to TensorRT engine conversion
data = """
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"
      }
    }
  }
}
"""

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

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

Docker kullanarak Triton Çıkarım Sunucusunu çalıştırın:

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:24.09-py3"  # 8.57 GB

# Pull the image
subprocess.call(f"docker pull {tag}", shell=True)

# Run the Triton server and capture the container ID
container_id = (
    subprocess.check_output(
        f"docker run -d --rm --gpus 0 -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
        shell=True,
    )
    .decode("utf-8")
    .strip()
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="localhost: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)

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

from ultralytics import YOLO

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

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

Konteyneri temizleyin:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)

By following the above steps, you can deploy and run Ultralytics YOLO11 models efficiently on Triton Inference Server, providing a scalable and high-performance solution for deep learning inference tasks. If you face any issues or have further queries, refer to the official Triton documentation or reach out to the Ultralytics community for support.

SSS

Ultralytics YOLO11'i NVIDIA Triton Inference Server ile nasıl kurabilirim?

Setting up Ultralytics YOLO11 with NVIDIA Triton Inference Server involves a few key steps:

  1. Export YOLO11 to ONNX format:

    from ultralytics import YOLO

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

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

  2. Triton Model Deposunu 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ın:

    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:24.09-py3"

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

container_id = (
    subprocess.check_output(
        f"docker run -d --rm --gpus 0 -v {triton_repo_path}/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
        shell=True,
    )
    .decode("utf-8")
    .strip()
)

triton_client = InferenceServerClient(url="localhost: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 model çıkarımı için YOLO11 modellerini Triton Inference Server üzerinde verimli bir şekilde dağıtmanıza yardımcı olabilir.

Ultralytics YOLO11'i NVIDIA Triton Çıkarım Sunucusu ile kullanmak ne gibi avantajlar sağlar?

Integrating Ultralytics YOLO11 with NVIDIA Triton Inference Server provides several advantages:

  • Ölçeklenebilir Yapay Zeka Çıkarsaması: Triton , tek bir sunucu örneğinden birden fazla modelin sunulmasına izin verir, dinamik model yükleme ve boşaltmayı destekler, bu da onu çeşitli yapay zeka iş yükleri için yüksek oranda ölçeklenebilir hale getirir.
  • High Performance: Optimized for NVIDIA GPUs, Triton Inference Server ensures high-speed inference operations, perfect for real-time applications such as object detection.
  • Topluluk ve Model Versiyonlama: Triton'un topluluk modu, sonuçları iyileştirmek için birden fazla modelin birleştirilmesini sağlar ve model versiyonlama, A/B testini ve sürekli güncellemeleri destekler.

For detailed instructions on setting up and running YOLO11 with Triton, you can refer to the setup guide.

Triton Inference Server'ı kullanmadan önce YOLO11 modelimi neden ONNX formatına aktarmalıyım?

Using ONNX (Open Neural Network Exchange) format for your Ultralytics YOLO11 model before deploying it on NVIDIA Triton Inference Server offers several key benefits:

  • 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ı, ONNX için optimize edilerek daha hızlı çıkarım ve daha iyi performans sağlar.
  • Dağıtım Kolaylığı: ONNX , çeşitli işletim sistemleri ve donanım yapılandırmalarında dağıtım sürecini basitleştiren çerçeveler ve platformlar arasında yaygın olarak desteklenmektedir.

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

from ultralytics import YOLO

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

İşlemi tamamlamak için dışa aktarma kılavuzundaki adımları takip edebilirsiniz.

Triton Çıkarım Sunucusunda Ultralytics YOLO11 modelini kullanarak çıkarım çalıştırabilir miyim?

Yes, you can run inference using the Ultralytics YOLO11 model on NVIDIA Triton Inference Server. Once your model is set up in the Triton Model Repository and the server is running, you can load and run inference on your model as follows:

from ultralytics import YOLO

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

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

For an in-depth guide on setting up and running Triton Server with YOLO11, refer to the running triton inference server section.

How does Ultralytics YOLO11 compare to TensorFlow and PyTorch models for deployment?

Ultralytics YOLO11 offers several unique advantages compared to TensorFlow and PyTorch models for deployment:

  • Real-time Performance: Optimized for real-time object detection tasks, YOLO11 provides state-of-the-art accuracy and speed, making it ideal for applications requiring live video analytics.
  • Ease of Use: YOLO11 integrates seamlessly with Triton Inference Server and supports diverse export formats (ONNX, TensorRT, CoreML), making it flexible for various deployment scenarios.
  • Advanced Features: YOLO11 includes features like dynamic model loading, model versioning, and ensemble inference, which are crucial for scalable and reliable AI deployments.

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

📅 Created 1 year ago ✏️ Updated 20 days ago
Y-T-G UltralitikAsistan glenn-jocher

Yorumlar