Overslaan naar inhoud

TensorRT Exporteren voor YOLOv8 modellen

Het implementeren van computervisie modellen in omgevingen met hoge prestaties kan een formaat vereisen dat snelheid en efficiƫntie maximaliseert. Dit geldt vooral als je je model inzet op NVIDIA GPU's.

Door het exportformaat TensorRT te gebruiken, kun je je Ultralytics YOLOv8 modellen verbeteren voor snelle en efficiƫnte inferentie op NVIDIA hardware. Deze gids geeft je eenvoudig te volgen stappen voor het conversieproces en helpt je om de geavanceerde technologie van NVIDIA optimaal te benutten in je deep learning-projecten.

TensorRT

TensorRT Overzicht

TensorRT, ontwikkeld door NVIDIA, is een geavanceerde software development kit (SDK) die is ontworpen voor high-speed deep learning inferentie. Het is zeer geschikt voor real-time toepassingen zoals objectdetectie.

Deze toolkit optimaliseert deep learning modellen voor NVIDIA GPU's en resulteert in snellere en efficiƫntere bewerkingen. TensorRT modellen ondergaan TensorRT optimalisatie, waaronder technieken als layer fusion, precisiekalibratie (INT8 en FP16), dynamisch tensor geheugenbeheer en kernel auto-tuning. Door deep learning modellen om te zetten naar het TensorRT formaat kunnen ontwikkelaars het potentieel van NVIDIA GPU's volledig benutten.

TensorRT staat bekend om zijn compatibiliteit met verschillende modelformaten, waaronder TensorFlow, PyTorch, en ONNX, waardoor ontwikkelaars een flexibele oplossing hebben voor het integreren en optimaliseren van modellen uit verschillende frameworks. Deze veelzijdigheid maakt het mogelijk om modellen efficiƫnt in te zetten in verschillende hardware- en softwareomgevingen.

Belangrijkste kenmerken van TensorRT modellen

TensorRT modellen bieden een aantal belangrijke eigenschappen die bijdragen aan hun efficiƫntie en effectiviteit in snelle deep learning inferentie:

  • Precisiekalibratie: TensorRT ondersteunt precisiekalibratie, waardoor modellen nauwkeurig kunnen worden afgestemd op specifieke nauwkeurigheidseisen. Dit omvat ondersteuning voor gereduceerde precisieformaten zoals INT8 en FP16, die de inferentiesnelheid verder kunnen verhogen met behoud van acceptabele nauwkeurigheidsniveaus.

  • Laagfusie: Het TensorRT optimalisatieproces omvat laagfusie, waarbij meerdere lagen van een neuraal netwerk worden gecombineerd in een enkele bewerking. Dit vermindert de computationele overhead en verbetert de inferentiesnelheid door de geheugentoegang en het rekenwerk te minimaliseren.

TensorRT Laagfusie

  • Dynamisch Tensor geheugenbeheer: TensorRT beheert efficiĆ«nt tensor geheugengebruik tijdens inferentie, waardoor geheugenoverhead wordt verminderd en geheugentoewijzing wordt geoptimaliseerd. Dit resulteert in efficiĆ«nter GPU geheugengebruik.

  • Automatische kerneltuning: TensorRT past automatische kerneltuning toe om de meest geoptimaliseerde GPU kernel te selecteren voor elke laag van het model. Deze adaptieve aanpak zorgt ervoor dat het model de rekenkracht van de GPU volledig benut.

Inzetmogelijkheden in TensorRT

Voordat we kijken naar de code voor het exporteren YOLOv8 modellen naar de TensorRT formaat, laten we begrijpen waar TensorRT modellen worden normaal gesproken gebruikt.

TensorRT biedt verschillende implementatieopties en elke optie heeft een andere balans tussen integratiegemak, prestatieoptimalisatie en flexibiliteit:

  • Implementeren binnen TensorFlow: Deze methode integreert TensorRT in TensorFlow, waardoor geoptimaliseerde modellen kunnen draaien in een vertrouwde TensorFlow omgeving. Het is handig voor modellen met een mix van ondersteunde en niet-ondersteunde lagen, omdat TF-TRT deze efficiĆ«nt kan afhandelen.

TensorRT Overzicht

  • Standalone TensorRT Runtime API: Biedt fijnmazige controle, ideaal voor toepassingen die kritisch zijn voor prestaties. Het is complexer, maar maakt aangepaste implementatie van niet-ondersteunde operatoren mogelijk.

  • NVIDIA Triton Inferentieserver: Een optie die modellen van verschillende frameworks ondersteunt. Deze is met name geschikt voor cloud- of edge-inferentie en biedt functies als gelijktijdige modeluitvoering en modelanalyse.

YOLOv8 modellen exporteren naar TensorRT

Je kunt de uitvoeringsefficiƫntie verbeteren en de prestaties optimaliseren door YOLOv8 modellen te converteren naar de indeling TensorRT .

Installatie

Voer het volgende uit om het vereiste pakket te installeren:

Installatie

# Install the required package for YOLOv8
pip install ultralytics

Bekijk voor gedetailleerde instructies en best practices met betrekking tot het installatieproces onze YOLOv8 Installatiegids. Als je tijdens de installatie van de vereiste pakketten voor YOLOv8 problemen tegenkomt, raadpleeg dan onze gids Veelgestelde problemen voor oplossingen en tips.

Gebruik

Voordat je in de gebruiksaanwijzing duikt, moet je eerst het assortiment YOLOv8 modellen bekijken dat Ultralytics aanbiedt. Dit zal je helpen het meest geschikte model te kiezen voor jouw projectvereisten.

Gebruik

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolov8n.engine'

# Load the exported TensorRT model
tensorrt_model = YOLO("yolov8n.engine")

# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine''

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Ga voor meer informatie over het exportproces naar de Ultralytics documentatiepagina over exporteren.

TensorRT exporteren met INT8 kwantisatie

Het exporteren van Ultralytics YOLO modellen met TensorRT met INT8 precisie voert post-training kwantisatie (PTQ) uit. TensorRT gebruikt kalibratie voor PTQ, die de verdeling van activeringen binnen elke activering tensor meet terwijl het YOLO model inferentie verwerkt op representatieve invoergegevens, en gebruikt vervolgens die verdeling om schaalwaarden te schatten voor elke tensor. Elke activering tensor die in aanmerking komt voor kwantisatie heeft een bijbehorende schaal die wordt afgeleid door een kalibratieproces.

Bij het verwerken van impliciet gekwantiseerde netwerken gebruikt TensorRT INT8 opportunistisch om de laaguitvoeringstijd te optimaliseren. Als een laag sneller werkt in INT8 en kwantisatieschalen heeft toegewezen aan de gegevensingangen en -uitgangen, dan wordt een kernel met INT8-precisie toegewezen aan die laag, anders selecteert TensorRT een precisie van FP32 of FP16 voor de kernel op basis van wat resulteert in een snellere uitvoeringstijd voor die laag.

Tip

Het is belangrijk om ervoor te zorgen dat hetzelfde apparaat dat de TensorRT modelgewichten gaat gebruiken voor de inzet, wordt gebruikt voor het exporteren met INT8 precisie, omdat de kalibratieresultaten per apparaat kunnen verschillen.

INT8 export configureren

De argumenten bij het gebruik van export voor een Ultralytics YOLO model zal zeer beĆÆnvloeden de prestaties van het geĆ«xporteerde model. Ze moeten ook worden geselecteerd op basis van de beschikbare apparaatbronnen, maar de standaardargumenten moet werken voor de meeste Ampere (of nieuwer) NVIDIA discrete GPU's. Het gebruikte kalibratiealgoritme is "ENTROPY_CALIBRATION_2" en je kunt meer details lezen over de beschikbare opties in de TensorRT Gids voor ontwikkelaars. Ultralytics tests toonden aan dat "ENTROPY_CALIBRATION_2" was de beste keuze en de export is vast ingesteld op het gebruik van dit algoritme.

  • workspace : Bepaalt de grootte (in GiB) van het toegewezen apparaatgeheugen tijdens het converteren van de modelgewichten.

    • Pas de workspace waarde afhankelijk van je kalibratiebehoeften en de beschikbare middelen. Terwijl een grotere workspace kan de kalibratietijd toenemen, maar het stelt TensorRT in staat om een breder scala aan optimalisatietactieken te verkennen, waardoor de prestaties en nauwkeurigheid van het model mogelijk verbeteren. Omgekeerd kan een kleinere workspace kan de kalibratietijd verkorten, maar kan de optimalisatiestrategieĆ«n beperken, waardoor de kwaliteit van het gekwantiseerde model wordt aangetast.

    • Standaard is workspace=4 (GiB), deze waarde moet mogelijk worden verhoogd als kalibratie vastloopt (zonder waarschuwing wordt afgesloten).

    • TensorRT zal rapporteren UNSUPPORTED_STATE tijdens het exporteren als de waarde voor workspace groter is dan het geheugen dat beschikbaar is voor het apparaat, wat betekent dat de waarde voor workspace moet worden verlaagd.

    • Als workspace is ingesteld op de maximumwaarde en de kalibratie mislukt/crasht, overweeg dan om de waarden voor imgsz en batch om minder geheugen nodig te hebben.

    • Onthoud dat kalibratie voor INT8 specifiek is voor elk apparaat, het lenen van een "high-end" GPU voor kalibratie kan resulteren in slechte prestaties wanneer inferentie wordt uitgevoerd op een ander apparaat.

  • batch : De maximale batchgrootte die wordt gebruikt voor inferentie. Tijdens inferentie kunnen kleinere batches worden gebruikt, maar inferentie zal geen batches accepteren die groter zijn dan wat is opgegeven.

Opmerking

Tijdens het kalibreren moet tweemaal de batch verstrekte maat worden gebruikt. Het gebruik van kleine batches kan leiden tot onnauwkeurig schalen tijdens het kalibreren. Dit komt doordat het proces zich aanpast op basis van de gegevens die het ziet. Het is mogelijk dat kleine batches niet het volledige waardenbereik vastleggen, wat leidt tot problemen met de uiteindelijke kalibratie. batch grootte automatisch verdubbeld. Als er geen partijgrootte is opgegeven batch=1wordt de kalibratie uitgevoerd op batch=1 * 2 om schaalfouten bij kalibratie te verminderen.

Experimenten door NVIDIA hebben geleid tot de aanbeveling om minstens 500 kalibratiebeelden te gebruiken die representatief zijn voor de gegevens van je model, met INT8 kwantiseringskalibratie. Dit is een richtlijn en geen hard vereiste, en moet je experimenteren met wat nodig is om goed te presteren voor jouw dataset. Omdat de kalibratiegegevens nodig zijn voor INT8-kalibratie met TensorRT, moet je de optie data argument wanneer int8=True voor TensorRT en gebruik data="my_dataset.yaml"die de afbeeldingen van validatie om mee te kalibreren. Als er geen waarde wordt doorgegeven voor data met export naar TensorRT met INT8 kwantisatie, wordt standaard een van de "kleine" voorbeelddatasets op basis van de modeltaak in plaats van een foutmelding te geven.

Voorbeeld

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    int8=True,
    data="coco.yaml",  # (4)!
)

# Load the exported TensorRT INT8 model
model = YOLO("yolov8n.engine", task="detect")

# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")
  1. Exporteert met dynamische assen, dit is standaard ingeschakeld bij exporteren met int8=True zelfs als het niet expliciet is ingesteld. Zie uitvoerargumenten voor meer informatie.
  2. Stelt de maximale partijgrootte in op 8 voor het geƫxporteerde model, dat kalibreert met batch = 2 * 8 om schaalfouten tijdens het kalibreren te voorkomen.
  3. Wijst 4 GiB geheugen toe in plaats van het hele apparaat toe te wijzen voor het conversieproces.
  4. Gebruikt COCO-dataset voor kalibratie, in het bijzonder de beelden die worden gebruikt voor validatie (5.000 in totaal).
# Export a YOLOv8n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolov8n.pt format=engine batch=8 workspace=4 int8=True data=coco.yaml  # creates 'yolov8n.engine''

# Run inference with the exported TensorRT quantized model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'
Kalibratie cache

TensorRT genereert een kalibratie .cache die kan worden hergebruikt om de export van toekomstige modelgewichten met dezelfde gegevens te versnellen, maar dit kan resulteren in een slechte kalibratie als de gegevens enorm verschillen of als de batch waarde drastisch wordt veranderd. In deze omstandigheden kan de bestaande .cache moet worden hernoemd en verplaatst naar een andere map of helemaal worden verwijderd.

Voordelen van het gebruik van YOLO met TensorRT INT8

  • Kleinere modelgrootte: Quantisatie van FP32 naar INT8 kan de grootte van het model 4x kleiner maken (op schijf of in het geheugen), wat leidt tot snellere downloadtijden, lagere opslagvereisten en een kleinere geheugenvoetafdruk bij het implementeren van een model.

  • Lager stroomverbruik: Gereduceerde precisiebewerkingen voor INT8 geĆ«xporteerde YOLO modellen kunnen minder stroom verbruiken in vergelijking met FP32 modellen, vooral voor apparaten die op batterijen werken.

  • Verbeterde inferentiesnelheden: TensorRT optimaliseert het model voor de doelhardware, wat kan leiden tot hogere inferentiesnelheden op GPU's, embedded apparaten en versnellers.

Opmerking over inferentiesnelheden

De eerste paar inferentie-aanroepen met een model dat geƫxporteerd is naar TensorRT INT8 zullen naar verwachting langer duren dan gebruikelijk bij preprocessing, inferentie en/of postprocessing. Dit kan ook voorkomen bij het veranderen van imgsz tijdens inferentie, vooral wanneer imgsz niet hetzelfde is als wat werd opgegeven tijdens het exporteren (export imgsz is ingesteld als TensorRT "optimaal" profiel).

Nadelen van het gebruik van YOLO met TensorRT INT8

  • Afname in evaluatiecijfers: Het gebruik van een lagere precisie betekent dat mAP, Precision, Recall of een andere metriek die wordt gebruikt om de modelprestaties te evalueren is waarschijnlijk iets erger. Zie de Prestatieresultaten om de verschillen in mAP50 en mAP50-95 bij het exporteren met INT8 op een kleine steekproef van verschillende apparaten.

  • Langere ontwikkeltijden: Het vinden van de "optimale" instellingen voor INT8 kalibratie voor dataset en apparaat kan een aanzienlijke hoeveelheid testen vergen.

  • Afhankelijkheid van hardware: Kalibratie en prestatiewinst kunnen sterk afhankelijk zijn van de hardware en modelgewichten zijn minder goed overdraagbaar.

Ultralytics YOLO TensorRT Exportprestaties

NVIDIA A100

Prestaties

Getest met Ubuntu 22.04.3 LTS, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Zie Detection Docs voor gebruiksvoorbeelden met deze modellen getraind op COCO, die 80 voorgetrainde klassen bevatten.

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch grootte
(pixels)
FP32 Voorspel 0.52 0.51 | 0.56 8 640
FP32 COCOval 0.52 0.52 0.37 1 640
FP16 Voorspel 0.34 0.34 | 0.41 8 640
FP16 COCOval 0.33 0.52 0.37 1 640
INT8 Voorspel 0.28 0.27 | 0.31 8 640
INT8 COCOval 0.29 0.47 0.33 1 640

Zie Segmentatiedocumenten voor gebruiksvoorbeelden met deze modellen getraind op COCO, die 80 voorgetrainde klassen bevatten.

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n-seg.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(M)
mAPval
50-95(M)
batch grootte
(pixels)
FP32 Voorspel 0.62 0.61 | 0.68 8 640
FP32 COCOval 0.63 0.52 0.36 0.49 0.31 1 640
FP16 Voorspel 0.40 0.39 | 0.44 8 640
FP16 COCOval 0.43 0.52 0.36 0.49 0.30 1 640
INT8 Voorspel 0.34 0.33 | 0.37 8 640
INT8 COCOval 0.36 0.46 0.32 0.43 0.27 1 640

Zie Classificatie Documenten voor gebruiksvoorbeelden met deze modellen getraind op ImageNet, die 1000 voorgetrainde klassen bevatten.

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n-cls.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
top-1 top-5 batch grootte
(pixels)
FP32 Voorspel 0.26 0.25 | 0.28 8 640
FP32 BeeldNetval 0.26 0.35 0.61 1 640
FP16 Voorspel 0.18 0.17 | 0.19 8 640
FP16 BeeldNetval 0.18 0.35 0.61 1 640
INT8 Voorspel 0.16 0.15 | 0.57 8 640
INT8 BeeldNetval 0.15 0.32 0.59 1 640

Zie Pose Estimation Docs voor gebruiksvoorbeelden met deze modellen getraind op COCO, die 1 voorgetrainde klasse, "persoon", bevatten.

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n-pose.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(P)
mAPval
50-95(P)
batch grootte
(pixels)
FP32 Voorspel 0.54 0.53 | 0.58 8 640
FP32 COCOval 0.55 0.91 0.69 0.80 0.51 1 640
FP16 Voorspel 0.37 0.35 | 0.41 8 640
FP16 COCOval 0.36 0.91 0.69 0.80 0.51 1 640
INT8 Voorspel 0.29 0.28 | 0.33 8 640
INT8 COCOval 0.30 0.90 0.68 0.78 0.47 1 640

Zie Oriented Detection Docs voor gebruiksvoorbeelden met deze modellen getraind op DOTAv1, die 15 voorgetrainde klassen bevatten.

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n-obb.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch grootte
(pixels)
FP32 Voorspel 0.52 0.51 | 0.59 8 640
FP32 DOTAv1val 0.76 0.50 0.36 1 640
FP16 Voorspel 0.34 0.33 | 0.42 8 640
FP16 DOTAv1val 0.59 0.50 0.36 1 640
INT8 Voorspel 0.29 0.28 | 0.33 8 640
INT8 DOTAv1val 0.32 0.45 0.32 1 640

GPU's voor consumenten

Detectieprestaties (COCO)

Getest met Windows 10.0.19045, python 3.10.9, ultralytics==8.2.4, tensorrt==10.0.0b6

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch grootte
(pixels)
FP32 Voorspel 1.06 0.75 | 1.88 8 640
FP32 COCOval 1.37 0.52 0.37 1 640
FP16 Voorspel 0.62 0.75 | 1.13 8 640
FP16 COCOval 0.85 0.52 0.37 1 640
INT8 Voorspel 0.52 0.38 | 1.00 8 640
INT8 COCOval 0.74 0.47 0.33 1 640

Getest met Windows 10.0.22631, python 3.11.9, ultralytics==8.2.4, tensorrt==10.0.1

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch grootte
(pixels)
FP32 Voorspel 1.76 1.69 | 1.87 8 640
FP32 COCOval 1.94 0.52 0.37 1 640
FP16 Voorspel 0.86 0.75 | 1.00 8 640
FP16 COCOval 1.43 0.52 0.37 1 640
INT8 Voorspel 0.80 0.75 | 1.00 8 640
INT8 COCOval 1.35 0.47 0.33 1 640

Getest met Pop!_OS 22.04 LTS, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch grootte
(pixels)
FP32 Voorspel 2.84 2.84 | 2.85 8 640
FP32 COCOval 2.94 0.52 0.37 1 640
FP16 Voorspel 1.09 1.09 | 1.10 8 640
FP16 COCOval 1.20 0.52 0.37 1 640
INT8 Voorspel 0.75 0.74 | 0.75 8 640
INT8 COCOval 0.76 0.47 0.33 1 640

Ingebedde apparaten

Detectieprestaties (COCO)

Getest met JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS, python 3.10.12, ultralytics==8.2.16, tensorrt==10.0.1

Opmerking

Inferentietijden getoond voor mean, min (snelste), en max (langzaamste) voor elke test met behulp van voorgetrainde gewichten yolov8n.engine

Precisie Eval test gemiddelde
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch grootte
(pixels)
FP32 Voorspel 6.11 6.10 | 6.29 8 640
FP32 COCOval 6.17 0.52 0.37 1 640
FP16 Voorspel 3.18 3.18 | 3.20 8 640
FP16 COCOval 3.19 0.52 0.37 1 640
INT8 Voorspel 2.30 2.29 | 2.35 8 640
INT8 COCOval 2.32 0.46 0.32 1 640

Evaluatiemethoden

Vouw de paragrafen hieronder uit voor informatie over hoe deze modellen zijn geƫxporteerd en getest.

Configuraties exporteren

Zie Exportmodus voor meer informatie over argumenten voor de exportconfiguratie.

from ultralytics import YOLO

model = YOLO("yolov8n.pt")

# TensorRT FP32
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2)

# TensorRT FP16
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, half=True)

# TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task)
out = model.export(
    format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, int8=True, data="coco8.yaml"
)
Voorspel lus

Zie Voorspellingsmodus voor meer informatie.

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
img = cv2.imread("path/to/image.jpg")

for _ in range(100):
    result = model.predict(
        [img] * 8,  # batch=8 of the same image
        verbose=False,
        device="cuda",
    )
Configuratie validatie

Zie val stand om meer te leren over validatie configuratieargumenten.

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet, or DOTAv1 for appropriate model task
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Geƫxporteerde YOLOv8 TensorRT modellen inzetten

Nadat je je Ultralytics YOLOv8 modellen met succes hebt geƫxporteerd naar het TensorRT formaat, ben je nu klaar om ze te implementeren. Voor uitgebreide instructies over het implementeren van je TensorRT modellen in verschillende instellingen, kun je een kijkje nemen in de volgende bronnen:

Samenvatting

In deze handleiding hebben we ons gericht op het converteren van Ultralytics YOLOv8 modellen naar NVIDIA's TensorRT model formaat. Deze conversiestap is cruciaal voor het verbeteren van de efficiƫntie en snelheid van YOLOv8 modellen, waardoor ze effectiever worden en geschikt zijn voor diverse implementatieomgevingen.

Kijk voor meer informatie over gebruiksdetails in de officiƫle documentatie opTensorRT .

Als je nieuwsgierig bent naar aanvullende Ultralytics YOLOv8 integraties, vind je op onze integratiegids pagina een uitgebreide selectie informatieve bronnen en inzichten.

FAQ

Hoe converteer ik YOLOv8 modellen naar TensorRT formaat?

Volg deze stappen om je Ultralytics YOLOv8 modellen te converteren naar TensorRT formaat voor geoptimaliseerde NVIDIA GPU inferentie:

  1. Installeer het vereiste pakket:

    pip install ultralytics
    
  2. Exporteer je YOLOv8 model:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine")  # creates 'yolov8n.engine'
    
    # Run inference
    model = YOLO("yolov8n.engine")
    results = model("https://ultralytics.com/images/bus.jpg")
    

Ga voor meer informatie naar YOLOv8 Installatiegids en de exportdocumentatie.

Wat zijn de voordelen van het gebruik van TensorRT voor YOLOv8 modellen?

Het gebruik van TensorRT om YOLOv8 modellen te optimaliseren biedt verschillende voordelen:

  • Snellere inferentie: TensorRT optimaliseert de modellagen en gebruikt precisiekalibratie (INT8 en FP16) om inferentie te versnellen zonder significant in te boeten aan nauwkeurigheid.
  • GeheugenefficiĆ«ntie: TensorRT beheert het geheugen van tensor dynamisch, waardoor de overhead wordt verminderd en het geheugengebruik van GPU wordt verbeterd.
  • Samenvoegen van lagen: Combineert meerdere lagen in een enkele bewerking, waardoor de computationele complexiteit afneemt.
  • Auto-afstemming kernel: Selecteert automatisch geoptimaliseerde GPU kernels voor elke modellaag, voor maximale prestaties.

Bekijk voor meer informatie de gedetailleerde functies van TensorRT hier en lees ons TensorRT overzichtsgedeelte.

Kan ik INT8 kwantisatie gebruiken met TensorRT voor YOLOv8 modellen?

Ja, je kunt YOLOv8 modellen exporteren met TensorRT met INT8 kwantisatie. Dit proces omvat post-training kwantisatie (PTQ) en kalibratie:

  1. Exporteren met INT8:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")
    
  2. Inferentie uitvoeren:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.engine", task="detect")
    result = model.predict("https://ultralytics.com/images/bus.jpg")
    

Raadpleeg voor meer details het gedeelte TensorRT exporteren met INT8 kwantisatie.

Hoe zet ik YOLOv8 TensorRT modellen in op een NVIDIA Triton Inferentieserver?

Het implementeren van YOLOv8 TensorRT modellen op een NVIDIA Triton Inference Server kan worden gedaan met behulp van de volgende bronnen:

Deze gidsen helpen je om YOLOv8 modellen efficiƫnt te integreren in verschillende implementatieomgevingen.

Wat zijn de waargenomen prestatieverbeteringen met YOLOv8 modellen geƫxporteerd naar TensorRT?

Prestatieverbeteringen met TensorRT kunnen variƫren afhankelijk van de gebruikte hardware. Hier zijn enkele typische benchmarks:

  • NVIDIA A100:

    • FP32-inferentie: ~0,52 ms / afbeelding
    • FP16-inferentie: ~0,34 ms / afbeelding
    • INT8 Inferentie: ~0,28 ms / afbeelding
    • Lichte vermindering in mAP met INT8 precisie, maar aanzienlijke verbetering in snelheid.
  • GPU's voor consumenten (bijvoorbeeld RTX 3080):

    • FP32-inferentie: ~1,06 ms / afbeelding
    • FP16-inferentie: ~0,62 ms / afbeelding
    • INT8 Inferentie: ~0,52 ms / afbeelding

Gedetailleerde prestatiebenchmarks voor verschillende hardwareconfiguraties zijn te vinden in het onderdeel Prestaties.

Voor uitgebreidere inzichten in de prestaties van TensorRT kun je de Ultralytics documentatie en onze prestatieanalyserapporten raadplegen.



Aangemaakt 2024-01-28, Bijgewerkt 2024-07-10
Auteurs: glenn-jocher (10), ambitious-octopus (1), lakshanthad ( 1), IvorZhu331 (1), Burhan-Q (2), abirami-vina (1)

Reacties