4.7 Modelexport en edge-implementatie

Waarom dit belangrijk is

In het vorige hoofdstuk hebben we uitgelegd hoe je een aangepast YOLO-model traint en succesvol inferentie uitvoert op Jetson. In dat stadium was het model nog opgeslagen in .pt-formaat, wat het native formaat is dat veel wordt gebruikt in het PyTorch-ecosysteem. Dit is een goed startpunt omdat het bewijst dat de trainingsresultaten correct zijn en dat het model al objectdetectie kan uitvoeren op het doelapparaat.

In het vorige hoofdstuk hebben we uitgelegd hoe je een aangepast YOLO-model traint en succesvol inferentie uitvoert op Jetson. In dat stadium was het model nog opgeslagen in .pt-formaat, wat het native formaat is dat veel wordt gebruikt in het PyTorch-ecosysteem. Dit is een goed startpunt omdat het bewijst dat de trainingsresultaten correct zijn en dat het model al objectdetectie kan uitvoeren op het doelapparaat.

Maar dat een model op Jetson kan draaien, betekent niet dat het al in zijn beste implementatievorm is. Het .pt-bestand is voornamelijk ontworpen voor training, validatie en ontwikkeling, waar flexibiliteit belangrijker is dan uitvoeringsefficiëntie. Voor daadwerkelijke edge-implementatie, vooral op embedded platforms zoals Jetson, geven we om veel meer dan alleen of het model kan draaien. We geven ook om hoe snel het draait, hoeveel geheugen het verbruikt, hoe stabiel de doorvoer is en hoe goed het past binnen de stroom- en thermische limieten van het apparaat.

Met andere woorden, een getraind checkpoint is slechts een deel van de implementatiepipeline. Om een YOLO-model echt geschikt te maken voor real-world Jetson-toepassingen, moeten we het meestal converteren naar een implementatievriendelijker formaat en het verder optimaliseren voor embedded inferentie. Dit is de cruciale stap die de kloof overbrugt tussen computer vision-ontwikkeling en edge-engineering.

Daarom is na het trainen van een model de volgende belangrijke vraag niet simpelweg "Kan het draaien?", maar eerder "Kan het efficiënt draaien op Jetson?" Om die vraag te beantwoorden, moeten we begrijpen waarom modeloptimalisatie nodig is.

Waarom hebben we modeloptimalisatie nodig?

Modeloptimalisatie is nodig omdat het oorspronkelijk getrainde model meestal niet is ontworpen voor de beperkingen van embedded hardware. Tijdens het trainen is het belangrijkste doel het bereiken van goede nauwkeurigheid en convergentie. Tijdens implementatie verandert het doel echter. We hebben nodig dat het model snelle inferentie, lage latentie, hoge doorvoer, laag geheugengebruik en goede energie-efficiëntie levert.

Dit is vooral belangrijk voor Jetson-apparaten. In vergelijking met desktop-GPUs of cloudservers hebben Jetson-platforms beperktere rekenresources, geheugenbandbreedte en stroombudget. In veel edge-AI-scenario's, zoals robotica, slimme camera's, industriële inspectie of autonome systemen, moet het model gegevens in real-time verwerken. Als de inferentie te traag is, kan het systeem frames missen, te laat reageren of niet voldoen aan de eisen van de toepassing.

Een YOLO-model direct in .pt-formaat draaien introduceert vaak onnodige overhead vanuit de PyTorch-runtime. Hoewel deze aanpak handig is voor testen en prototypen, is het niet ideaal om de maximale prestaties uit Jetson-hardware te halen. Het model werkt mogelijk correct, maar gebruikt de GPU mogelijk niet zo efficiënt mogelijk. Als gevolg daarvan kan de latentie hoog blijven, de doorvoer beperkt zijn en het resourcegebruik groter dan nodig.

Modeloptimalisatie helpt deze problemen op te lossen. Door het model te exporteren en te optimaliseren voor inferentie, kunnen we de manier waarop het netwerk op de doelhardware wordt uitgevoerd verbeteren. Dit kan het verminderen van overbodige operaties, het samenvoegen van lagen, het selecteren van efficiëntere kernels, het verlagen van precisie van FP32 naar FP16 of INT8 en het verbeteren van geheugengebruik omvatten. Deze optimalisaties kunnen de implementatieprestaties aanzienlijk verbeteren zonder de algemene taak van het model te veranderen.

Voor Jetson-implementatie biedt optimalisatie verschillende praktische voordelen:

1. Lagere latentie

Een sneller model betekent dat elk invoerframe sneller kan worden verwerkt. Dit is cruciaal voor real-time taken zoals objectdetectie en -tracking.

2. Hogere doorvoer

Optimalisatie stelt het systeem in staat meer frames per seconde te verwerken, wat belangrijk is voor video-analyse en multistream-toepassingen.

3. Lager geheugengebruik

Embedded apparaten hebben beperkte geheugenresources. Een geoptimaliseerd model kan de geheugenvoetafdruk verkleinen en de systeemstabiliteit verbeteren.

4. Betere energie-efficiëntie

Jetson-apparaten worden vaak gebruikt in edge-omgevingen waar stroomverbruik belangrijk is. Een efficiënter model kan helpen het systeem langer en betrouwbaarder te laten draaien.

5. Betere benutting van hardware

Optimalisatie stelt het model in staat beter gebruik te maken van NVIDIA GPU-versnelling in plaats van sterk te leunen op generieke frameworkuitvoering.

Om deze redenen is modeloptimalisatie niet slechts een optionele verbetering. Het is een noodzakelijke stap om een getraind YOLO-model te transformeren in een praktische edge-AI-oplossing die efficiënt kan draaien onder echte implementatieomstandigheden.

Wat is TensorRT?

TensorRT is NVIDIA's high-performance deep learning-inferentieframework en runtime. Het is specifiek ontworpen om getrainde neurale netwerken te optimaliseren en efficiënt uit te voeren op NVIDIA-hardware, inclusief Jetson-apparaten.

Eenvoudig gezegd is TensorRT de tool die helpt een getraind model te converteren naar een vorm die beter geschikt is voor implementatie. In plaats van het model te draaien via een algemeen deep learning-framework, bouwt TensorRT een geoptimaliseerde inferentie-engine die is afgestemd op de doel-NVIDIA-GPU. Hierdoor kan het model sneller en efficiënter draaien.

Voor Jetson speelt TensorRT een centrale rol bij implementatie omdat het is ontworpen om de mogelijkheden van NVIDIA-embedded-GPUs volledig te benutten. Het voert verschillende optimalisaties uit, zoals:

• layer fusion, waarbij meerdere operaties worden gecombineerd in een efficiëntere uitvoeringspad
• kernel auto-selectie, waarbij de beste implementatie voor de hardware wordt gekozen
• precisie-optimalisatie, zoals FP16- of INT8-versnelling
• geheugenoptimalisatie, die onnodige geheugenbeweging vermindert en de runtime-efficiëntie verbetert

Als gevolg daarvan kan TensorRT de inferentieprestaties van een YOLO-model aanzienlijk verbeteren in vergelijking met het direct draaien van het oorspronkelijke .pt-model.

Een typische Jetson-implementatieworkflow ziet er zo uit:

PyTorch .pt-model -> ONNX-model -> TensorRT-engine -> Jetson-inferentie

In deze workflow:

• is het .pt-model het trainingsresultaat
• dient het ONNX-model als tussenliggend uitwisselingsformaat
• is de TensorRT-engine het geoptimaliseerde implementatieartefact dat wordt gebruikt voor inferentie op Jetson

Dit proces toont aan dat TensorRT niet alleen een converter is, maar een belangrijke optimalisatie- en uitvoeringslaag voor embedded AI-implementatie.

Vanuit engineeringperspectief is TensorRT belangrijk omdat het een model dat slechts trainbaar en testbaar is verandert in een model dat echt implementeerbaar en efficiënt is. Voor Jetson-gebruikers is TensorRT vaak de belangrijkste stap om praktische real-time prestaties te bereiken.

Met andere woorden, een getraind checkpoint is slechts een deel van de implementatiepipeline. Om een YOLO-model echt geschikt te maken voor real-world Jetson-toepassingen, moeten we het meestal converteren naar een implementatievriendelijker formaat en het verder optimaliseren voor embedded inferentie. Dit is de cruciale stap die de kloof overbrugt tussen computer vision-ontwikkeling en edge-engineering.

Veelvoorkomende modelformaten

Nauwkeurigheid vs Snelheid vs Energie

Een nauwkeuriger model is vaak groter, langzamer en verbruikt meer stroom, terwijl een sneller model vaak lichter maar minder nauwkeurig is. Bij echte implementatie moeten we dus een balans vinden die past bij het apparaat en de taak. Edge-implementatie draait altijd om afwegingen.

Vaak balanceer je:

• modelnauwkeurigheid
• inferentiesnelheid
• geheugengebruik
• thermische en energielimieten

Precisiemodi

Modelprecisie betekent hoeveel bits worden gebruikt om getallen op te slaan in het model, zoals gewichten en activeringen. Hogere precisie, zoals FP32, behoudt meer numerieke details, terwijl lagere precisie, zoals FP16 of INT8, minder bits gebruikt. Lagere precisie kan inferentie sneller maken en minder geheugen gebruiken, wat erg nuttig is op edge-apparaten zoals Jetson. Maar als de precisie te veel wordt verlaagd, kan het model wat nauwkeurigheid verliezen, dus we moeten snelheid en betrouwbaarheid in balans brengen.

Codevoorbeeld

Exporteren naar ONNX

yolo export model=yolo26s.pt format=onnx imgsz=640

Exporteren naar TensorRT op Jetson

yolo export model=yolo26s.pt format=engine imgsz=640 half=True device=0

Nuttige Jetson-runtime-commando's

#turn on max mode
sudo nvpmodel -m 0
#turn on jetson clocks
sudo jetson_clocks

Probeer het uit

cd 4.7-Model-Export-and-Edge-Deployment/code
python compare_yolo26_pt_vs_engine.py --video ./cat.mp4

🚀 Bekijk de veranderingen in de inferentielatentie van het geoptimaliseerde model

Veelvoorkomende misverstanden

• "Als het model succesvol exporteert, is de implementatie opgelost."
  • Export is slechts één stap. Runtime-validatie is nog steeds belangrijk.
• "Het snelste model is altijd het beste model."
  • Een sneller model is niet nuttig als het belangrijke gevallen mist.
• "INT8 is altijd beter dan FP16."
  • INT8 kan sterk zijn, maar alleen als de nauwkeurigheid acceptabel blijft.

Oefeningen / Reflectie

1. Exporteer een getraind model naar ONNX en noteer het commando.
2. Vergelijk schriftelijk waar elk van deze het beste voor is: checkpoint, ONNX, TensorRT engine.
3. Stel je voor dat een model nauwkeurig maar te traag is. Noem drie manieren om de implementatie praktischer te maken.
4. Leg uit waarom de stroommodus belangrijk is op een edge-apparaat.

Samenvatting

Modelexport en edge-implementatie zijn geen bijzaken. Ze zijn onderdeel van de volledige computer vision-workflow. Nadat een leerling data, training en evaluatie heeft begrepen, is de volgende uitdaging om dat model om te zetten in iets praktisch voor echte hardware.

Voorgestelde volgende stap

Ga verder met 4.8 Real-time vision pipeline-frameworks.

Referenties

• https://onnx.ai/onnx/intro/
• Ultralytics Export Mode
• Ultralytics TensorRT Integration
• TensorRT Developer Guide
• https://developer.nvidia.com/blog/speeding-up-deep-learning-inference-using-tensorrt-updated/