Overslaan naar inhoud

Triton Inferentieserver met Ultralytics YOLOv8

De Triton Inference Server (voorheen bekend als TensorRT Inference Server) is een open-source softwareoplossing ontwikkeld door NVIDIA. Het biedt een cloud-inferentieoplossing die is geoptimaliseerd voor NVIDIA GPU's. Triton vereenvoudigt de inzet van AI-modellen op schaal in productie. Door Ultralytics YOLOv8 te integreren met Triton Inference Server kun je schaalbare, krachtige deep learning inferentiewerklasten implementeren. Deze handleiding bevat stappen om de integratie op te zetten en te testen.



Kijken: Aan de slag met NVIDIA Triton Inferentieserver.

Wat is Triton Inferentieserver?

Triton Inference Server is ontworpen om verschillende AI-modellen in productie te nemen. Het ondersteunt een breed scala aan deep learning en machine learning frameworks, waaronder TensorFlow, PyTorch, ONNX Runtime en vele andere. De primaire gebruikssituaties zijn:

  • Meerdere modellen serveren vanaf een enkele serverinstantie.
  • Dynamisch laden en ontladen van modellen zonder de server opnieuw op te starten.
  • Ensemble-inferentie, waardoor meerdere modellen samen kunnen worden gebruikt om resultaten te bereiken.
  • Modelversie voor A/B-testen en doorlopende updates.

Vereisten

Zorg ervoor dat je aan de volgende voorwaarden voldoet voordat je verder gaat:

  • Docker geĆÆnstalleerd op je machine.
  • Installeer tritonclient:
    pip install tritonclient[all]
    

YOLOv8 exporteren naar ONNX

Voordat het model wordt ingezet op Triton, moet het worden geƫxporteerd naar het ONNX formaat. ONNX (Open Neural Network Exchange) is een formaat waarmee modellen kunnen worden overgedragen tussen verschillende deep learning frameworks. Gebruik de export functie van de YOLO klasse:

from ultralytics import YOLO

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

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

Triton Modelrepository instellen

De Triton Model Repository is een opslaglocatie waar Triton modellen kan openen en laden.

  1. Maak de benodigde mappenstructuur:

    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. Verplaats het geƫxporteerde ONNX model naar het Triton archief:

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

Triton Inferentieserver uitvoeren

Voer de Triton Inference Server uit met 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:23.09-py3"  # 6.4 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 -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)

Voer dan inferentie uit met het Triton Server model:

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

Ruim de container op:

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

Door de bovenstaande stappen te volgen, kun je Ultralytics YOLOv8 modellen efficiƫnt implementeren en uitvoeren op Triton Inference Server, wat een schaalbare en krachtige oplossing biedt voor deep learning inferentietaken. Als je tegen problemen aanloopt of nog vragen hebt, raadpleeg dan de officiƫle Triton documentatie of neem contact op met de Ultralytics community voor ondersteuning.

FAQ

Hoe stel ik Ultralytics YOLOv8 in met NVIDIA Triton Inference Server?

Het instellen Ultralytics YOLOv8 met NVIDIA Triton Inference Server bestaat uit een paar belangrijke stappen:

  1. Exporteer YOLOv8 naar ONNX formaat:

    from ultralytics import YOLO
    
    # Load a model
    model = YOLO("yolov8n.pt")  # load an official model
    
    # Export the model to ONNX format
    onnx_file = model.export(format="onnx", dynamic=True)
    
  2. Triton Modelrepository instellen:

    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. Start de Triton Server:

    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:23.09-py3"
    
    subprocess.call(f"docker pull {tag}", shell=True)
    
    container_id = (
        subprocess.check_output(
            f"docker run -d --rm -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)
    

Deze opzet kan je helpen om YOLOv8 modellen efficiƫnt op schaal in te zetten op Triton Inference Server voor krachtige AI modelinferentie.

Welke voordelen biedt het gebruik van Ultralytics YOLOv8 met NVIDIA Triton Inference Server?

Integratie van Ultralytics YOLOv8 met NVIDIA Triton Inference Server biedt verschillende voordelen:

  • Schaalbare AI-inferentie: Triton maakt het mogelijk om meerdere modellen te serveren vanaf een enkele serverinstantie en ondersteunt het dynamisch laden en lossen van modellen, waardoor het zeer schaalbaar is voor diverse AI-workloads.
  • Hoge prestaties: Triton Inference Server is geoptimaliseerd voor NVIDIA GPU's en garandeert snelle inferentiebewerkingen, perfect voor realtime toepassingen zoals objectdetectie.
  • Ensemble en modelversie: De ensemblemodus van Triton maakt het mogelijk om meerdere modellen te combineren om de resultaten te verbeteren, en de modelversie ondersteunt A/B-testen en rolling updates.

Voor gedetailleerde instructies over het instellen en uitvoeren van YOLOv8 met Triton, kun je de installatiegids raadplegen.

Waarom moet ik mijn YOLOv8 model exporteren naar het ONNX formaat voordat ik Triton Inference Server gebruik?

Het gebruik van ONNX (Open Neural Network Exchange) formaat voor je Ultralytics YOLOv8 model voordat je het implementeert op NVIDIA Triton Inference Server biedt verschillende belangrijke voordelen:

  • Interoperabiliteit: Het formaat ONNX ondersteunt de overdracht tussen verschillende raamwerken voor diep leren (zoals PyTorch, TensorFlow) en zorgt zo voor een bredere compatibiliteit.
  • Optimalisatie: Veel implementatieomgevingen, waaronder Triton, optimaliseren voor ONNX, waardoor inferentie sneller en betere prestaties mogelijk zijn.
  • Eenvoudige implementatie: ONNX wordt breed ondersteund door frameworks en platforms, waardoor het implementatieproces in verschillende besturingssystemen en hardwareconfiguraties wordt vereenvoudigd.

Gebruik om je model te exporteren:

from ultralytics import YOLO

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

Je kunt de stappen in de gids voor exporteren volgen om het proces te voltooien.

Kan ik inferentie uitvoeren met het Ultralytics YOLOv8 model op Triton Inference Server?

Ja, je kunt inferentie uitvoeren met het Ultralytics YOLOv8 model op NVIDIA Triton Inferentie Server. Zodra je model is ingesteld in de Triton Model Repository en de server draait, kun je als volgt inferentie op je model laden en uitvoeren:

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

Voor een uitgebreide handleiding over het opzetten en uitvoeren van Triton Server met YOLOv8, raadpleeg je de sectie over het uitvoeren van triton inferentieserver.

Hoe verhoudt Ultralytics YOLOv8 zich tot TensorFlow en PyTorch modellen voor inzet?

Ultralytics YOLOv8 biedt verschillende unieke voordelen ten opzichte van TensorFlow en PyTorch modellen voor implementatie:

  • Real-time prestaties: YOLOv8 is geoptimaliseerd voor realtime objectdetectietaken en biedt ultramoderne nauwkeurigheid en snelheid, waardoor het ideaal is voor toepassingen die live videoanalyse vereisen.
  • Gebruiksgemak: YOLOv8 integreert naadloos met Triton Inference Server en ondersteunt verschillende exportformaten (ONNX, TensorRT, CoreML), waardoor het flexibel is voor verschillende implementatiescenario's.
  • Geavanceerde functies: YOLOv8 bevat functies zoals het dynamisch laden van modellen, modelversie en ensemble-inferentie, die cruciaal zijn voor schaalbare en betrouwbare AI implementaties.

Vergelijk voor meer details de implementatieopties in de handleiding voor het implementeren van modellen.



Gemaakt op 2023-11-12, Bijgewerkt op 2024-07-05
Auteurs: glenn-jocher (10)

Reacties