Vai al contenuto

Triton Server di inferenza con Ultralytics YOLO11

Triton Inference Server (precedentemente noto come TensorRT Inference Server) è una soluzione software open-source sviluppata da NVIDIA. Offre una soluzione di inferenza in cloud ottimizzata per le GPU NVIDIA . Triton semplifica l'implementazione di modelli di intelligenza artificiale su scala in produzione. L'integrazione di Ultralytics YOLO11 con Triton Inference Server consente di distribuire carichi di lavoro di inferenza di deep learning scalabili e ad alte prestazioni. Questa guida fornisce i passaggi per impostare e testare l'integrazione.



Guarda: Come iniziare con NVIDIA Triton Inference Server.

Che cos'è Triton Inference Server?

Triton Inference Server è stato progettato per distribuire una serie di modelli di intelligenza artificiale in produzione. Supporta un'ampia gamma di framework di deep learning e machine learning, tra cui TensorFlow, PyTorch, ONNX Runtime e molti altri. I suoi casi d'uso principali sono:

  • Servire più modelli da un'unica istanza del server.
  • Caricamento e scaricamento dinamico del modello senza riavvio del server.
  • Inferenza ensemble, che consente di utilizzare più modelli insieme per ottenere risultati.
  • Versioni del modello per test A/B e aggiornamenti continui.

Prerequisiti

Prima di procedere, accertatevi di disporre dei seguenti prerequisiti:

  • Docker installato sulla macchina.
  • Installare tritonclient: 
    pip install tritonclient[all]

Esportazione di YOLO11 nel formato ONNX

Prima di distribuire il modello su Triton, è necessario esportarlo nel formato ONNX . ONNX (Open Neural Network Exchange) è un formato che consente di trasferire i modelli tra diversi framework di deep learning. Utilizzare il formato export dalla funzione YOLO classe:

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)

Impostazione del repository di modelli Triton

Il Repository dei modelli di Triton è un luogo di archiviazione in cui Triton può accedere e caricare i modelli.

  1. Creare la struttura di directory necessaria:

    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. Spostare il modello esportato ONNX nel repository Triton :

    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)

Esecuzione del server di inferenza Triton

Eseguire il server di inferenza Triton utilizzando Docker:

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)

Quindi eseguire l'inferenza utilizzando il modello di Triton Server:

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

Pulire il contenitore:

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

Seguendo i passi sopra descritti, è possibile distribuire ed eseguire i modelli Ultralytics YOLO11 in modo efficiente su Triton Inference Server, fornendo una soluzione scalabile e ad alte prestazioni per le attività di inferenza dell'apprendimento profondo. In caso di problemi o di ulteriori domande, consultare la documentazione ufficiale di Triton o rivolgersi alla comunità di Ultralytics per ottenere supporto.

FAQ

Come si configura Ultralytics YOLO11 con NVIDIA Triton Inference Server?

La configurazione Ultralytics YOLO11 con NVIDIA Triton Inference Server comporta alcuni passaggi chiave:

  1. Esportazione di YOLO11 in formato ONNX :

    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. Impostare il repository di modelli Triton :

    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. Eseguire il server Triton :

    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)

Questa configurazione può aiutarvi a distribuire in modo efficiente i modelli di YOLO11 in scala su Triton Inference Server per l'inferenza di modelli di intelligenza artificiale ad alte prestazioni.

Quali vantaggi offre l'utilizzo di Ultralytics YOLO11 con NVIDIA Triton Inference Server?

L'integrazione Ultralytics YOLO11 con NVIDIA Triton Inference Server offre diversi vantaggi:

  • Inferenza AI scalabile: Triton consente di servire più modelli da una singola istanza del server, supportando il caricamento e lo scaricamento dinamico dei modelli e rendendolo altamente scalabile per diversi carichi di lavoro AI.
  • Prestazioni elevate: Ottimizzato per le GPU NVIDIA , Triton Inference Server garantisce operazioni di inferenza ad alta velocità, perfette per applicazioni in tempo reale come il rilevamento di oggetti.
  • Ensemble e Model Versioning: la modalità ensemble di Triton consente di combinare più modelli per migliorare i risultati, mentre il versioning dei modelli supporta i test A/B e gli aggiornamenti continui.

Per istruzioni dettagliate sull'impostazione e l'esecuzione di YOLO11 con Triton, è possibile consultare la guida all'installazione.

Perché devo esportare il mio modello YOLO11 nel formato ONNX prima di usare Triton Inference Server?

L'utilizzo del formato ONNX (Open Neural Network Exchange) per il modello Ultralytics YOLO11 prima di distribuirlo su NVIDIA Triton Inference Server offre diversi vantaggi chiave:

  • Interoperabilità: il formato ONNX supporta il trasferimento tra diversi framework di deep learning (come PyTorch, TensorFlow), garantendo una maggiore compatibilità.
  • Ottimizzazione: Molti ambienti di distribuzione, tra cui Triton, ottimizzano per ONNX, consentendo un'inferenza più rapida e migliori prestazioni.
  • Facilità di distribuzione: ONNX è ampiamente supportato da diversi framework e piattaforme, semplificando il processo di distribuzione in diversi sistemi operativi e configurazioni hardware.

Per esportare il modello, utilizzare:

from ultralytics import YOLO

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

Per completare il processo è possibile seguire i passi della guida all'esportazione.

È possibile eseguire l'inferenza utilizzando il modello Ultralytics YOLO11 su Triton Inference Server?

Sì, è possibile eseguire l'inferenza utilizzando il Ultralytics YOLO11 su NVIDIA Triton Inference Server. Una volta che il modello è impostato nel Repository dei modelli Triton e il server è in funzione, è possibile caricare ed eseguire l'inferenza sul modello come segue:

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

Per una guida approfondita sull'impostazione e l'esecuzione di Triton Server con YOLO11, consultare la sezione Esecuzione del server di inferenza triton .

Come si colloca Ultralytics YOLO11 rispetto a TensorFlow e PyTorch modelli per la distribuzione?

Ultralytics YOLO11 offre diversi vantaggi unici rispetto ai modelli TensorFlow e PyTorch per la distribuzione:

  • Prestazioni in tempo reale: Ottimizzato per le attività di rilevamento di oggetti in tempo reale, YOLO11 offre precisione e velocità all'avanguardia, rendendolo ideale per le applicazioni che richiedono l'analisi di video dal vivo.
  • Facilità d'uso: YOLO11 si integra perfettamente con Triton Inference Server e supporta diversi formati di esportazione (ONNX, TensorRT, CoreML), rendendolo flessibile per vari scenari di implementazione.
  • Funzionalità avanzate: YOLO11 include funzionalità come il caricamento dinamico dei modelli, il versioning dei modelli e l'inferenza di ensemble, che sono fondamentali per implementazioni di IA scalabili e affidabili.

Per maggiori dettagli, confrontate le opzioni di distribuzione nella guida alla distribuzione del modello.

📅C reato 1 anno fa ✏️ Aggiornato 22 giorni fa
Y-T-G Assistente Ultralitico glenn-jocher

Commenti