Ontwerp en implementatie van een veldprogrammeerbaar poortarray-gebaseerd voetgangersdetectieframework voor autonome rijtoepassingen

Summary

Dit onderzoeksartikel demonstreert de implementatie van een realtime voetgangersdetectie-algoritme op veldprogrammeerbare gate-arrayhardware, voornamelijk voor autonome rijtoepassingen. Het algoritme combineert het histogram van georiënteerde gradiënten (HoG) met een support vector machine (SVM) classifier, en de resultaten tonen efficiëntie in termen van snelheid, energieverbruik en middelengebruik.

Abstract

Autonoom rijden biedt een veelbelovende manier om het toenemende aantal dodelijke slachtoffers door verkeersongevallen aan te pakken. Een autonoom voertuig heeft veel functies, maar het vermogen om voetgangers te detecteren is cruciaal, uitdagend en relevant voor verschillende realtime situaties zoals bewaking, het volgen van mensen en monitoring. Het nauwkeurig identificeren van voetgangers is moeilijk omdat ze in verschillende vormen, posities en houdingen kunnen verschijnen. Ze kunnen verschillende soorten kleding dragen en soms gedeeltelijk verborgen zijn of opgaan in nabijgelegen objecten. Dit artikel richt zich op de realtime detectie van voetgangers voor zelfrijdende auto's met behulp van een populair hardwareplatform: de field programmable gate array (FPGA), Ultra 96 v2. De studie implementeert een methode voor voetgangersdetectie gebaseerd op een histogram van georiënteerde gradiënten (HOG) gecombineerd met een support vector machine (SVM) classifier om individuen op het FPGA-bord te herkennen, gebruikmakend van high-level synthesis (HLS) tools. De effectiviteit van het systeem is getest op zowel stilstaande beelden als live video. De resultaten tonen aan dat geavanceerde FPGA-kaarten zoals de Ultra 96 v2 de prestatie-indicatoren aanzienlijk verbeteren. Het systeem werkt op een kloksnelheid van 150 MHz, gebruikt minder dan de helft van de beschikbare middelen en verbruikt ongeveer 2,5 W vermogen. Ook rapporteert het systeem de nauwkeurigheid van voetgangersdetectie rond 95% en andere efficiënte indicatoren voor detectie-evaluatie, zoals precisie (78,6%), terugroep (88,3%) en F1-score (83,1%). Samenvattend kan het ontwikkelde systeem voetgangers in realtime detecteren en heeft het het potentieel om de ontwikkeling van een slimme en veilige vervoersomgeving aanzienlijk te verbeteren.

Introduction

Stedelijke ontwikkeling en het ontstaan van slimme steden zijn wereldwijd interessante onderwerpen. Alle landen werken aan de ontwikkeling van hun steden die zo gebouwd kunnen worden dat ze veilig en comfortabel zijn voor de mensen die er wonen ^1,2. Maar in de huidige situatie is waargenomen dat, naarmate de bevolking groeit en de verkeerscongestie toeneemt, het aantal dodelijke slachtoffers als gevolg van verkeersongevallen door nalatigheid en slechte zichtproblemen alarmerend toeneemt. Een veelbelovende oplossing voor deze problemen is de opkomst van autonome voertuigen wereldwijd, wat innovatie heeft aangewakkerd ^1,2,3,4 en onderzoekers doen inspanningen om volledig autonome voertuigen te ontwikkelen waarmee passagiers zich zorgeloos kunnen ontspannen. De noodzaak voor de ontwikkeling van autonome voertuigen komt voort uit het feit dat zelfs ervaren bestuurders te maken kunnen krijgen met stress, dilemma's, vermoeidheid of moeite met het waarnemen van hun omgeving door slecht weer, en al deze problemen leiden tot verkeersonvallen. Een zelfrijdend voertuig is ontworpen om ongelukken tijdens het reizen te voorkomen, het motorverbruik te optimaliseren en te voldoen aan verkeersregels, wat het vervoer ongetwijfeld zal verbeteren ^2,4. Een autonoom voertuig is uitgerust met meerdere functies, sensoren en functies waarmee het zijn omgeving zeer nauwkeurig kan waarnemen en botsingen en ongelukken voorkomt, en daarom zijn ze nu uitgegroeid tot een veelbelovende oplossing om het transport veilig en beveiligd te maken 1,2,3,4.

Van alle functies die in een autonoom voertuig zijn opgenomen, is een van de belangrijkste de detectie van voetgangers. Een robuust voetgangersdetectiesysteem kan aanzienlijk bijdragen aan het verlagen van het aantal dodelijke^{slachtoffers bij} verkeersongevallen met ^5,6,7,8, aangezien de meerderheid van de slachtoffers van deze ongevallen voetgangers zijn. Voetgangersdetectie houdt in dat je personen op de weg identificeert en botsingen met hen vermijdt. Deze functie is niet alleen nuttig voor zelfrijdende auto's, maar ook voor diverse andere toepassingsgebieden zoals crowd monitoring, persoonsidentificatie en het volgen van ^9,10,11. Het belangrijkste aspect van dit detectieproces is de snelheid en nauwkeurigheid van de detectie. Het is cruciaal om voetgangers nauwkeurig en snel te detecteren, zodat de reactietijd minimaal is. Er is een enorme uitdaging door voetgangersdetectie. Voetgangers op de weg kunnen in elke kleding, uiterlijk of houding zijn en kunnen onzichtbaar zijn door slecht weer of occlusie 10,11,12,13,14. Bovendien is het heel goed mogelijk dat voetgangers de regels zelf niet volgen, en men kan de menselijke natuur niet beheersen, dus de beste aanpak is om het voertuig uit te rusten met de intelligentie om eventuele verkeerde acties uit te voeren en dodelijke slachtoffers te voorkomen. De volledige verloop van het werk in dit onderzoek en de motivatie achter de hardware-implementatie van voetgangersdetectie is eenvoudig te begrijpen uit Figuur 1 hieronder, die de noodzaak van voetgangersdetectie, de verschillende toepassingsgebieden, de uitdagingen en de implementatie op een FPGA om de geboden voordelen te benutten, uitlegt.

Figuur 1: Voetgangersdetectie. De behoefte aan voetgangersdetectie, belangrijke toepassingsgebieden van voetgangersdetectie, de uitdagingen bij voetgangersdetectie en de implementatieflow van voetgangersdetectie op een FPGA-bord. Klik hier om een grotere versie van deze figuur te bekijken.

Om voetgangers op de weg te identificeren, bestaan er talloze algoritmen. Deze algemene taak kan primair worden onderverdeeld in twee hoofdsubtaken: de eerste stap extraheert kenmerken uit een invoerafbeelding, waarbij alleen die belangrijke en relevante informatie worden overgebracht, terwijl de overbodige worden genegeerd. Voor een effectieve herkenning van mensen of voetgangers in een afbeelding is het cruciaal dat deze kenmerken de aanwezigheid van een menselijke figuur in scène^13,14 aangeven. Na deze extractie moeten de kenmerken naar een classifier worden gestuurd die kan bepalen of de geïdentificeerde kenmerken overeenkomen met een mens. Daarom vereist het algoritme een fase van feature-extractie en -beschrijving, gevolgd door een classificatiestap om de aanwezigheid van voetgangers in de invoerscène te bepalen. Er zijn verschillende algoritmen beschikbaar voor dit doel. De meest geaccepteerde methode voor voetgangersdetectie tot nu toe blijft echter de combinatie van het histogram van georiënteerde gradiënten (HoG) met de support vector machine (SVM) classifier ^12,13,14,15. Er bestaan talrijke voorbeelden van softwareontwikkelingen, maar uiteindelijk is het doel om de implementatie te porten naar een compatibel hardwareplatform, dat vervolgens in het applicatiesysteem kan worden geïntegreerd voor realtime gebruik. Daarom ligt de huidige nadruk op hardwarerealisatie. Er kan dus worden gesteld dat het noodzakelijk is om een geschikte hardware-implementatie van voetgangersdetectiesystemen te ontwikkelen, waarbij camera's met de juiste hardware op voertuigen kunnen worden geplaatst en voetgangers op de weg kunnen identificeren. Bij het overwegen welke hardware geschikt is voor dergelijke implementaties, is een van de meest gebruikte opties de field programmable gate array (FPGA) vanwege de vele voordelen, waaronder kortere ontwerptijd, schaalbaarheid, eenvoudige aanpassingen, herconfigureerbaarheid en lager energie- en energieverbruik 15,16,17,18,19,20,21,²².

FPGA-kaarten zijn consequent geëvolueerd en worden nu veel gebruikt voor complexe, geavanceerde computer vision-toepassingen die variëren van basis beeldverwerking tot objectdetectie, augmented reality en deep learning 20,21,22. Momenteel bieden verschillende high-performance FPGA-kaarten uitzonderlijke architecturale mogelijkheden om de uitgebreide verwerking te accommoderen die nodig is voor deze ingewikkelde toepassingen. Als de geavanceerde functies van autonome voertuigen, zoals voetgangersdetectie, op dergelijke hardwareplatforms worden geïmplementeerd, kunnen deze platforms zeer nuttig zijn voor snelle prototypeontwikkeling om prestaties te analyseren, en na optimalisatie kan het geïmplementeerde algoritme worden overgezet naar daadwerkelijke geïntegreerde schakelingen voor integratie in het systeem.

Al meer dan tien jaar zijn er belangrijke publicaties over de implementatie van voetgangersdetectie met de HoG- en SVM-methode op verschillende FPGA-platforms. Tabel 1 vat de artikelen in dit vakgebied samen in de periode 2015–2025 15,16,17,18,19,20,21,22,23,24, met de nadruk op de belangrijkste factoren zoals de beeldresolutie, de doorvoersnelheid, of de frames per seconde (FPS), het type classifier, en de belangrijkste hoogtepunten of bijdragen van de papier.

Referentie	FPGA-platform	Beeldresolutie	Classifier	Belangrijke hoogtepunten / bijdragen
15	Xilinx Zynq	640×480	AdaBoost	Realtime FPGA-implementatie; resource-efficiënt; gebruikt binarisatie voor optimalisatie; Goede detectienauwkeurigheid.
16	Terasic's DE1-SOC-bord	640×480	SVM	Hoogwaardige HOG-extractor; integreert SVM; enkelvoudige detectie; Pipeline met lage latentie.
17	Altera DE2-115	640×480	AdaBoost	Beoordeelt prestaties vanuit meerdere gezichtspunten; FPGA-implementatie van HOG+AdaBoost; realtime voetgangersdetectie.
18	Intel Stratix V	640×480	SVM	Multi-scale voetgangersdetectie; FPGA-vriendelijke HOG+SVM-pijplijn; benadrukt afwegingen tussen nauwkeurigheid en hardware-efficiëntie.
19	Zynq UltraScale+ MPSoC	3840×2160	SVM	Realtime UHD-verwerking; gepijplijnde HOG+SVM; SoC FPGA-implementatie; vastepuntoptimalisatie; schaalbare architectuur.
20	Niet gespecificeerd	Niet gespecificeerd	SVM	Bereikt >95% detectienauwkeurigheid; realtime FPGA-implementatie; maakt gebruik van parallelisme; gedetailleerd HOG+SVM FPGA-ontwerp voor voetgangersdetectie.
21	Zync 7000 FPGA	1920×1080	SVM	High-throughput streamarchitectuur voor HOG+SVM; ondersteunt HD-resolutie; efficiënte pijplijn voor FPGA-versnelling.
22	Ultra96 (rev1)	240×320	SVM	FPGA-implementatie met HLS; detecteert rode verkeerslichten; berekent waarschijnlijkheden in 891 regio's; De latentie varieert van 153.838 tot 19 cycli.
23	Xilinx Zynq-7000 FPGA	640 × 480	HOG + SVM	Voetgangersdetectie geïmplementeerd met HOG-SVM op FPGA, wat realtime prestaties behaalde met een lager stroomverbruik vergeleken met CPU-verwerking. Geïmproviseerde geoptimaliseerde feature-extractiepijplijn geschikt voor embedded vision-toepassingen.
24	Xilinx Virtex-6 FPGA	640 × 480	Vastpuntobjectdetector (Haar-achtige kenmerken)	Voorgestelde high-throughput FPGA-versnelling van objectdetectie met behulp van fixed-point arithmetica, waardoor de rekenkosten worden verlaagd en de nauwkeurigheid behouden blijft. Toonde een snelheidsstijging van 15× ten opzichte van CPU-implementaties met efficiënt hardwaregebruik.

Tabel 1: Literatuuroverzicht van onderzoek gebaseerd op voetgangersdetectie op FPGA (2015–2025).

Tabel 1 vat samen dat er uitgebreide literatuur is op het gebied van voetgangersdetectie, en dat hardware-implementatie het interessegebied is voor onderzoekers. Het is ook duidelijk dat er geavanceerde deep learning- en machine learning-technieken zijn, zoals convolutionele neurale netwerken (CNN's) gebaseerde detectoren zoals YOLO, transformer-gebaseerde architecturen, enzovoort, voor de taak van voetgangersdetectie. Ze presteren zelfs beter dan het traditionele HoG-algoritme qua nauwkeurigheid, maar als je de hardware-implementatie meeneemt, leiden de geavanceerde algoritmen tot een enorm resourceverbruik^{van 23,24} vanwege de complexiteit van het algoritme, wat ook andere prestatieparameters kan beïnvloeden, en er is ook waargenomen dat door de extra complexiteit de snelheid iets beter is in het geval van het traditionele HoG-algoritme^{24. 25}. Er is ook waargenomen dat de geavanceerde technieken meer energie verbruiken wanneer ze worden geïmplementeerd op hardware^24,26. Het doel van het werk in dit artikel is dus om voetgangersdetectie uit te voeren met het traditionele HoG- en SVM-framework op FPGA-hardware en zo een gunstige afweging tussen nauwkeurigheid, snelheid, resource en vermogen te bereiken voor realtime embedding. Uit Tabel 1 blijkt duidelijk dat wanneer het HoG- en SVM-gebaseerde werk wordt geanalyseerd, wordt opgemerkt dat er beperkte publicaties zijn die het recent geïntroduceerde Zynq UltraScale+ MPSoC (Multi-Processor System On Chip) gebaseerde FPGA-ontwikkelingsbord²⁷ hebben gebruikt om de mogelijkheden van deze kaarten te verkennen, aangezien deze borden vanuit architectuurperspectief zijn geëvolueerd, en bieden veel potentieel voor de implementatie van hoogwaardige realtime computer vision-toepassingen. Er zijn beperkte publicaties die het volledige voetgangersdetectiesysteem in realtime op de FPGA-borden hebben gerealiseerd. Ze hebben zich echter gericht op de efficiënte implementatie of verbetering van de tussentijdse taken. Bovendien zijn de meeste van deze implementaties gebaseerd op het realiseren van het volledige systeem op een FPGA-kaart via het gebruik van hardwarebeschrijvingstalen. Weinigen hebben de voordelen van High Level Synthesis (HLS) tools gebruikt om de ontwerpcyclus te versnellen. Dit artikel demonstreert het ontwerp en de implementatie van realtime voetgangersdetectie op een FPGA-bord dat is toegewezen aan een autonome rijtoepassing. Het artikel maakt gebruik van het HoG- en SVM-framework voor voetgangersdetectie op stilstaande beelden, video of echte camera-invoer. De gebruikte hardware is een geavanceerd en recent uitgebracht FPGA-kaart, de Ultra96 v2, een geavanceerde FPGA-architectuur die een krachtig platform is voor computer vision, beeldverwerking, machine learning, edge computing, enzovoort^. De Ultra96 v2 is een ontwikkelbord met een Arm-gebaseerde AMD Xilinx Zynq UltraScale+ MPSoC²⁷. Dit bord omvat het verwerkingssysteem (PS) segment, dat bestaat uit ARM-gebaseerde CPU-cores die de softwareaspecten van het project beheren, en het Programmable Logic (PL) segment dat aanpasbare hardware-versnelling mogelijk maakt 20,21,22. Samen verbeteren deze componenten de functionaliteit van een hybride systeem, waarbij het PS-gedeelte de besturing en interactie met externe elementen beheert, terwijl het PL-deel de daadwerkelijke verwerkingslogica verzorgt.

Protocol

De implementatieprocedure die in dit onderzoek wordt gebruikt, gebaseerd op voetgangersdetectie met HoG + SVM op een FPGA-bord, waarbij de voordelen van hoog-niveau synthese worden benut, wordt geïllustreerd in Figuur 2 hieronder.

Figuur 2: Ontwerpprocedure voor de implementatie van voetgangersdetectie op het FPGA-bord. Fase 1: Voetgangersdetectie-algoritme met HoG+SVM op de HLS-tool en generatie van een IP-blok. Fase 2: Voetgangersdetectie-algoritme met HoG+SVM voor de daadwerkelijke FPGA-implementatie en het genereren van het bitbestand. Fase 3: Het bord programmeren met het gegenereerde bitbestand. Klik hier om een grotere versie van deze figuur te bekijken.

1. Voetgangersdetectie met HoG en SVM op de HLS-tool

1. Download de Python Integrated Development Environment (IDE) afhankelijk van de systeemeigenschappen waarop de download wordt uitgevoerd.
   OPMERKING: In dit werk wordt de versie Python 3.10 gebruikt.
2. Voer een Python-script uit om een trainingsmodel uit te voeren met het HoG-algoritme en de SVM-classifier. Begin het script met het laden van de positieve en negatieve monsters uit de dataset.
   OPMERKING: Gebruik de INRIA-dataset¹¹.
3. Haal de HoG-functies eruit voor een raamformaat van 64 x 128.
4. Verdeel de trainings- en testgegevens uit de INRIA-dataset tot een verhouding van 80/20 met willekeurige schuddingen voor reproduceerbaarheid.
   OPMERKING: De dataset wordt willekeurig geschud met de python-functie voordat de data wordt gesplitst. Om reproduceerbaarheid te waarborgen zodat elke keer dat een seedwaarde in de code wordt vastgesteld, dezelfde splitsing wordt uitgevoerd.
5. Train met behulp van de C-support vector classification (SVC) SVM met een lineaire kernel.
6. Haal de gewichtsvectoren en de bias eruit.
7. Bewaar de SVM-gewichten en de bias in het vaste punt Q8.8-formaat voor de FPGA-implementatie.
   OPMERKING: De conversie gebeurt door de originaliteit van elke floating-point waarde te schalen die wordt gegenereerd met een factor 256 (2⁸) en het resultaat te omzetten naar een geheel getal.
8. Test het getrainde model via een ander Python-script en pas de regularisatieparameter C aan, totdat de nauwkeurigheid meer dan 95% is.
   OPMERKING: Geoptimaliseerde regularisatieparameter verkregen: C = 0,05.
9. Open de HLS-tool en maak een nieuw project aan met het onderdeelnummer geselecteerd als xczu3eg-sbva484-1-e.
10. Schrijf een voetgangersdetectiecode op het high-level synthese-instrument met behulp van high-level talen zoals C++.
11. In de code schrijf je drie verschillende C++-scripts: één voor de HoG-feature-descriptor en de SVM-classifier, een andere voor de testbench om input te leveren aan de testimages en de uitvoerimages op te slaan, en de derde voor een headerbestand dat de parameters in de code aangeeft.
12. In de code voor HoG-featureberekening wordt de afbeelding aangepast naar 640 x 480 en een schuifvensterarchitectuur toegepast met een venstergrootte van 64 x 128. Voor elk raam bereken je de gradiëntgrootte en oriëntatie voor elk overlappend blok van 8 x 8.
    OPMERKING: Het is belangrijk om het hele beeld te scannen via het sliding window-concept zodat elk deel van het beeld wordt bedekt en voetgangers van elke mogelijke grootte worden geïdentificeerd.
13. In het andere deel van dezelfde code voor de HoG-feature-descriptor geef je de berekende gradiënten door aan de SVM-classifier. Schrijf de code om de kenmerken te koppelen aan de classifiergewichten en vergelijk met de drempel om de gedetecteerde eigenschap te classificeren als die van een mens of niet.
14. Klik op Run C Simulation in de HLS-tool om de code te simuleren met behulp van een testbank om de functionaliteit van de code te controleren.
15. Geef verschillende invoerbeelden aan de code en controleer de uitvoerbeelden met de gedetecteerde voetgangers.
16. Klik op Run C Synthesis om de code te synthetiseren en de code door de tool aan hardwaretalen toe te wijzen en de rapporten van timing en gebruik te genereren.
    OPMERKING: De tool opent automatisch de HLS-syntheserapporten. Dit rapport toont de schatting van de vereiste klokfrequentie voor het implementeren van de gecodeerde taak op het geselecteerde FPGA-platform, en geeft ook een schatting van de gebruikte middelen. Deze gerapporteerde waarden zijn slechts schattingen en de daadwerkelijke parameters worden pas berekend na implementatie op de FPGA-kaart.
17. Klik op Export RTL om het Intellectual Property (IP) blok voor het HoG-algoritme voor voetgangersdetectie te exporteren.
    OPMERKING: Dit IP zal worden gebruikt in de latere fasen van de implementatie.

2. Het programmeren van de FPGA-kaart

1. Open de tool voor FPGA-programmeren en maak een nieuw project. Selecteer het onderdeelnummer als xczu3eg-sbva484-1-e en maak een nieuw blokontwerp.
   OPMERKING: Dit blokdiagram is gemaakt om integratie te creëren tussen het PS- en het PL-gedeelte van de FPGA-printplaat. Het gebruikte communicatieprotocol is het Advanced eXtensible Interface (AXI) protocol.
2. Zoek naar de IP-catalogus in de tool en zodra je hem hebt gevonden, open je hem.
3. Maak een gebruikersrepository aan door het pad van het geëxporteerde RTL-IP toe te voegen in stap 1.17.
4. In het nieuwe blokontwerpvenster klik je nu met de rechtermuisknop en selecteer je IP toevoegen. Alle IP's zijn zichtbaar, inclusief die welke door de tool worden aangeboden en door de door gebruikers toegevoegde repositories.
5. Voeg het Zync Ultrascale PS-blok toe uit de repository.
   OPMERKING: Dit blok weerspiegelt het PS-gedeelte van het systeem, dat verantwoordelijk is voor het genereren van de benodigde klokken, en het heeft ook de master- en slavepoorten voor verbinding met het geïmporteerde HoG-IP via het AXI-interconnectblok, dat draait op de AXI-protocolbasisprincipes.
6. Voeg 8 HoG IP's toe omdat het systeem 8 vensters tegelijkertijd verwerkt om optimaal gebruik te maken van het voordeel van parallelisme dat het FPGA-bord biedt.
7. Voeg een processorsysteem-resetblok toe, dat ook de klok aanstuurt en de resetvoeding aan elk blok in het diagram regelt.
8. Voeg twee axi_smart connects blocks toe om de HoG IP's met het Zync PS-blok te verbinden. Het volledige blokdiagram met de volledige verbindingen is weergegeven in Figuur 3.
   OPMERKING: Zoals weergegeven in Figuur 3, zijn alle blokken die aan het ontwerp moeten worden toegevoegd duidelijk weergegeven. Figuur 3 is vastgelegd vanuit het gereedschap en toont de interne poorten van elk blok, evenals de verbindingen tussen de poorten van verschillende blokken. Dit blok is het hoofdontwerp omdat het verantwoordelijk is voor het tot stand brengen van de interface tussen het PS- en het PL-gedeelte van de FPGA-kaart.
9. Na het voltooien van de verbindingen zoals in figuur 3, klik je op validate design.
   OPMERKING: Validatie controleert in feite de ontbrekende of kapotte verbindingen, wat later tot problemen kan leiden.
10. Klik op synthese en vervolgens Implement design in de tool nadat de validatie van het blokdiagram succesvol is.
    OPMERKING: Synthesis brengt het ontworpen blokdiagram in kaart en zet het in kaart op de FPGA-printplaat. Deze stap meldt eventuele overtredingen die erop wijzen dat het ontwerp niet op hardware kan worden geïmplementeerd.
11. De tool genereert ook rapporten over timing, middelengebruik en stroomverbruik. Controleer de rapporten zorgvuldig om te controleren op eventuele tijdsovertredingen en analyseer de prestaties van het ontworpen systeem.
12. Klik op Generate the bitstream file , wat het .bit-bestand genereert dat nodig is voor het programmeren van het FPGA-bord.

Figuur 3: Blokdiagram voor voetgangersdetectie met HoG + SVM geïmporteerd IP. Klik hier om een grotere versie van deze figuur te bekijken.

3. Definitieve implementatie op het FPGA-bord

1. Pak het FPGA-bord en steek de SD-kaart met het juiste afbeeldingsbestand in de sleuf op het bord.
2. Sluit het bord ook aan op de computer.
3. Start het FPGA-bord op in SD-kaartmodus om Python-programmering erop in te schakelen^21,22.
4. Toegang tot het jupyter-platform op het bord nadat je het met de wifi hebt verbonden.
5. Sluit een webcamera aan op het bord.
6. Schrijf een pythoncode om het gegenereerde bitbestand te importeren en voer de taak uit om de camerabeelden te benaderen.
7. In de code schrijf je het script zo dat de afbeelding via het PS-deel in het geheugen van het FPGA-bord wordt geschreven en vervolgens aan het PL-gedeelte wordt doorgegeven voor verwerking.
   OPMERKING: Het PL-gedeelte van het bord dat overeenkomt met de HoG-IP's benadert de beeldpixels via deze geheugenlocaties, verwerkt deze en levert de scores als output.
8. Schrijf passende code in hetzelfde Python-script om de verwerkte afbeeldingen te lezen en op het computerscherm weer te geven.
   OPMERKING: Dit maakt het volledige ontwerp compleet en het systeem is nu klaar voor inzet in praktijktoepassingen. Alle codes die in deze studie worden gebruikt, worden geüpload als aanvullende coderingsbestanden (Aanvullend Bestand 1 [Script_1_train_test.py], Aanvullend Bestand 2 [Script_2_HLS_hog.cpp], Aanvullend Bestand 3 [Script_3_HLS_test_bench.cpp], Aanvullend Bestand 4 [Script_4_HLS_consts.h], Aanvullend Bestand 5 [Script_5_jupyter_code.txt]).

Results

Implementatie van voetgangersdetectie op HLS
Figuur 4 toont de simulatieresultaten op de HLS-tool voor de voetgangersdetectie met HoG + SVM. Een invoerbeeld met een voetganger wordt als testinvoer aan de code toegevoegd, en de output met de gedetecteerde voetgangers wordt weergegeven. Er zijn twee secties in de afbeelding. De eerste detectie heeft steeds weer veel begrenzende vakken rond dezelfde voetganger, en in de tweede afbeelding worden de overlappende vakken verwijderd en onderdrukt, waardoor alleen de hoofddetectievakken overblijven.

Figuur 4: Simulatieresultaat van de HLS-tool. (A,B) Twee verschillende invoerbeelden en de resulterende beelden met de gedetecteerde voetgangers. Klik hier om een grotere versie van deze figuur te bekijken.

De HLS-tool levert ook syntheserapporten voor de timing en het gebruik van middelen. De tijdsoverzicht benadrukt de tijdsperiode die het ontwerp vereist en geeft de maximale en minimale latentiewaarden in termen van het aantal cycli. Deze informatie is nuttig om in te schatten hoeveel tijd het ontwerp nodig heeft om uit te voeren en wat de kloksnelheid moet zijn bij de overstap naar de daadwerkelijke hardware-implementatie. Tabel 2 hieronder toont het timingrapport na de HLS-synthese, dat duidelijk aangeeft dat de beoogde klokperiode 6 ns was en het ontwerp 5,25 ns duurde, wat minder is dan het doel, en daarom kan de tijdsperiode 6ns of hoger zijn maar niet onder de 5 ns.

Tijdsoverzicht
Klok	Doel	Geschat
	6,00 ns	5.250 ns
Gebruikssamenvatting
	Totaal / Beschikbaar	Percentage van het gebruik
BRAM18K	22 / 432	5%
DSP48E	13 / 360	3%
FF	5611/ 141120	3%
LUT	9904/ 70560	14%
URAM	0	0

Tabel 2: Geschatte timing- en resourcebenuttingsrapport van de HLS-tool voor voetgangersdetectie met HoG-SVM.

Tabel 2 toont ook het gebruiksrapport. Het toont het percentage gebruik van belangrijke aan boord FPGA-bronnen volgens het geselecteerde doelbord. Voor dit voetgangersdetectieontwerp toont het gebruiksrapport aan dat het ontwerp 14% van de look-up tables (LUTs), 3% van Flip Flops (FFs), 3% van digitale signaalverwerking (DSP) en 5% van block random access memory (BRAM) verbruikt. Deze schattingen zijn niet de exacte gebruiksrapporten, maar de daadwerkelijke rapporten liggen dicht bij deze schattingen. Dit zijn alleen de schattingen die door de HLS-tools kunnen worden berekend. De daadwerkelijke uitvoering verschilt meestal sterk van deze schattingen.

Daadwerkelijke implementatieresultaten uit hardwareprogrammering
Nadat de code is omgezet in een IP, die wordt geïmporteerd in de FPGA-programmeertool, en het ontwerp is geïmplementeerd op de daadwerkelijke FPGA-hardware, worden er ook verschillende rapporten gegenereerd. De eerste is de timingoverzicht, die laat zien of de klokfrequentie die aan het ontwerp wordt toegevoegd voldoende is of niet. Als aan alle tijdsbeperkingen wordt voldaan en er geen overtredingen zijn, kan het ontwerp doorgaan. Tabel 3 hieronder toont de tijdsoverzicht die door het hulpmiddel is gegenereerd. Zoals weergegeven in de tabel, geeft de tijdsoverzicht de slechtste negatieve slack aan, namelijk 4,073 ns. Omdat deze waarde positief is, geeft het aan dat er nog zoveel tijd beschikbaar is. Negatieve waarden geven aan dat de FPGA meer tijd nodig heeft om de taak te voltooien en dat de klok snel loopt. Aangezien er in dit geval geen negatieve waarden zijn, wat aangeeft dat aan de timingbeperkingen is voldaan.

Samenvatting van de ontwerptiming
Opstelling	Houd vast	Pulsbreedte
Slechtste negatieve slack 4,073 ns	Slechtste Hold-slack 0,010 ns	Slechtste pulsbreedte: Slack 3,500 ns

Tabel 3: Werkelijke tijdsoverzicht voor voetgangersdetectie op het FPGA-bord.

Ook toont de tool de rapporten over het gebruik van de middelen, die het daadwerkelijke gebruik van de boordbronnen weergeven volgens het geselecteerde FPGA-bord. In dit geval is het geselecteerde bord het Zynq UltraScale+ MPSoC (Multi-Processor System On Chip) gebaseerd FPGA-ontwikkelingsbord²⁷. Tabel 4 hieronder toont het resourcegebruik en Figuur 5 toont de diagrammatische weergave van het resourcegebruik.

De gebruikssamenvatting geeft het werkelijke verbruik van de boordmiddelen aan, aangezien er 8 HoG IPS parallel worden gebruikt, en de schattingen gerapporteerd door de HLS-synthese waren voor één enkele HoG IP. Maar zelfs na zo'n intensief gebruik is de resourcebenutting voor elke hulpbron minder dan 50%. Tabel 4 geeft duidelijk het gebruik aan met betrekking tot de verschillende hulpbronnen en hun benuttingspercentage, wat beeldend wordt weergegeven in Figuur 5.

Bron	Gebruik	Beschikbaar	Benuttingspercentage
LUT	40536	70560	57.45%
LUTRAM	7304	28800	25.36%
FF	33342	141120	23.63%
BRAM	68	216	31.48%
DSP	128	360	35.56%
BUFG	2	196	1.02%

Tabel 4: Rapport over daadwerkelijk gebruik voor voetgangersdetectie op het FPGA-bord.

Figuur 5: Resourcegebruik voor voetgangersdetectie op het FPGA-bord na daadwerkelijke implementatie. Zoek tabellen op (LUT): 57%, LUTRAM: 25%, Flipflops (FF): 24%, Block RAM (BRAM): 31%, Digitale signaalprocessors (DSP): 36%, Buffers: 1%. Klik hier om een grotere versie van deze figuur te bekijken.

Het derde rapport betreft de vermogensschattingen van de board voor het energieverbruik van het ontwerp. Figuur 6 hieronder toont het stroomverbruiksrapport, waaruit blijkt dat het totale on-chip vermogen 2,435 W is. De verbinding temperatuur en het vermogen dat door elk belangrijk net en component wordt verbruikt, worden ook weergegeven. De stroommetingen tonen geen alarmerend stroomverbruik aan, waardoor het ontwerp als energie-efficiënt kan worden beschouwd.

Figuur 6: Vermogensschatting voor voetgangersdetectie op het FPGA-bord na daadwerkelijke implementatie. Het energierapport dat door de tools wordt gegenereerd, geeft het totale verbruikte vermogen weer als 2,435 W en toont ook de verdeling van het vermogen over de verschillende bronnen op het FPGA-bord. Klik hier om een grotere versie van deze figuur te bekijken.

Een andere analyse wordt uitgevoerd om het voordeel te begrijpen van het gebruik van 8 HoG-IP's in plaats van één HoG-IP of meer dan 8 in het aangemaakte blokdiagram, zoals weergegeven in Figuur 3. De hardware-gerelateerde prestatie-metrics werden parallel berekend voor zowel één HoG IP als 8 HoG IP's. Tabel 5 hieronder toont de vergelijking.

Perfromancemetriek	1 IP	8 IP's
Timing (ns)	5.312	~5,25
Frequentie (MHz)	188	150
Vermogen (W)	1.9	2.43
LUTs	4998	40536
FF / Registers	4,031	33,342
DSP	16	128
BRAM	8.5	68
FPS	~10–11	83

Tabel 5: Vergelijking van prestatie-indicatoren met behulp van enkele versus meerdere HoG-IP's.

Tabel 5 geeft duidelijk aan dat wanneer de bronnen worden meegenomen zoals de LUT's, FF's, DSP's en BRAM, dan bij één HoG IP en 8 HoG IP's, de schaalverdeling lineair is met bijna 8 keer een toename van het gebruikte middelen. Dit is duidelijk te verwachten, aangezien meer IP's zullen leiden tot meer verbruik van middelen. Ook, als de frequentie wordt waargenomen, neemt de maximale frequentie ook licht met 20% af van 188 MHz naar 150 MHz. Dit wordt ook verwacht omdat meer blokken leiden tot meer verbindingen en dus langere paden, wat leidt tot een toename van kritieke paden. Maar de voordelige factoren zoals frames per seconde (FPS) verbeteren van 10 naar 83, wat nonlineaire schaalvergroting in het geval van FPS aantoont dankzij het geïntroduceerde concept van parallelisme, vanwege 8 HoG IP's. Ook schaalt het vermogen van 1,9 W naar 2,4 W, wat wijst op verbeterde energie-efficiëntie door leidingleiding. Deze analyse geeft dus duidelijk aan dat de introductie van 8 HoG-IP's gunstig is voor het ontwerp, en dat schalen boven 8 kan leiden tot overmatig gebruik van middelen; Daarom worden het aantal blokken boven de 8 niet als gunstig beschouwd.

Resultaten van voetgangersdetectie na FPGA-implementatie
Ten slotte wordt het hele systeem geïntegreerd op de FPGA-kaart en wordt het bitstreambestand gegenereerd, dat vervolgens op het bord wordt geprogrammeerd via de SD-kaart die met Python-programmeerbaarheid wordt opgestart. Zodra het bord met de SD-kaart is opgestart, kan de jupyter-interface worden benaderd en kan Python-code op het platform worden geschreven en uitgevoerd. De Python-code wordt uitgevoerd en getest op voetgangersdetectie op verschillende invoerafbeeldingen. Het resultaat van enkele afbeeldingen is te zien in Figuur 7 hieronder. Deze beelden worden gebruikt uit de INRIA-dataset evenals willekeurige beelden van voetgangers afkomstig uit open source online bronnen^26,27.

Figuur 7: Voetgangersdetectieresultaten op stilstaande beelden via FPGA Board. De geteste beelden omvatten beelden uit de INRIA-dataset, open source afbeeldingen die via Google beschikbaar zijn om detectienauwkeurigheid te testen op drukke wegen in India. Klik hier om een grotere versie van deze figuur te bekijken.

Het systeem wordt ook getest op realtime beeldopnames via een webcamera en het detecteren van voetgangers in het beeld, evenals het systeem wordt getest op reeds opgenomen video-invoer van voetgangers. De resultaten hiervan zijn weergegeven in Figuur 8 en Figuur 9. Figuur 8 toont een reeks voorbeeldframes die door de webcamera zijn vastgelegd en de resultaten van voetgangersdetectie in elk frame, terwijl Figuur 9 de resultaten van voetgangersdetectie toont die zijn geïmplementeerd op een invoervideo die aan het systeem wordt geleverd.

Figuur 8: Voetgangersdetectieresultaten op een frame dat door een camera in realtime via het FPGA-bord is vastgelegd. Realtime video vastleggen met webcamera 720 P en demonstreren van realtime detectie van voetgangers. De wazige beelden ontstaan doordat er snapshots worden genomen van de lopende livevideo. Klik hier om een grotere versie van deze figuur te bekijken.

Figuur 9: Voetgangersdetectieresultaten op video's die als input aan het FPGA-bord worden geleverd. De video's zijn afkomstig van open source links. Klik hier om een grotere versie van deze figuur te bekijken.

Schatting van prestatiemetrics
Om de efficiëntie te berekenen en de prestaties van het hierboven geïmplementeerde ontwerp te analyseren, is het essentieel om prestatie-indicatoren te berekenen die nuttig zijn om de prestaties te evalueren. De prestatiemetrics voor het detecteren van de efficiëntie van een detectiealgoritme zijn in wezen afhankelijk van waarden van echte positieven (TP), ware negatieven (TN), vals-positieven (FP) en valse negatieven (FN). Uit deze waarden kunnen prestatie-indicatoren zoals precisie, herinnering, F1-score, valse positieven per afbeelding en nauwkeurigheid worden berekend volgens de onderstaande vergelijkingen. Er is waargenomen dat de meeste onderzoeksartikelen hun detectieprestaties rapporteren via de nauwkeurigheidsparameter. Maar er is waargenomen dat de nauwkeurigheidsberekening waarbij TN wordt gebruikt een misleidende parameter kan zijn, omdat de waarde van TN niet correct in de juiste zin kan worden berekend, omdat het inhoudt dat alle detectievensters in een afbeelding zonder voetganger worden gevonden, en het geïmplementeerde algoritme ook rapporteert dat er geen detecties zijn. Dit aantal is over het algemeen erg groot, omdat het totale aantal detectievensters in een afbeelding groot is, en de achtergrondgebieden in elke afbeelding meestal overeenkomen met gebieden zonder voetgangers. Door nauwkeurig te kijken naar de nauwkeurigheidsformule zoals weergegeven in vergelijkingen [1] – [5], kan worden vastgesteld dat omdat de waarde van TN vrij hoog zal zijn vergeleken met TP+FP+FN, de nauwkeurigheidsparameter meestal een hoge waarde heeft. Om de prestaties echt te evalueren, is het veel beter om de statistieken zoals precisie, herinnering en F1-score te rapporteren die niet afhankelijk zijn van TN en dus veel nauwkeuriger zijn.

[1]

[2]

[3]

[4]

[5]

Om de waarden van TP, TN en FN voor dit artikel te vinden, werd het experiment op de stilstaande beelden herhaald op een groot aantal beelden. Uit de resultaten van elk beeld werd de waarde van echte positieven, dat wil zeggen het aantal correct gedetecteerde voetgangers, vals-positieven, het aantal foutieve voetgangers en valse negatieven, oftewel de daadwerkelijke onontdekte voetgangers, berekend. De volgende waarden werden gerapporteerd na de uitgevoerde experimenten en worden weergegeven in Tabel 6 hieronder.

Prestatiemaatstaf	Waarde
TP	143
FP	39
FN	19
Precison	0.786 (78.6%)
Terugroeping	0.883 (88.3%)
F1-score	0.831 (83.1%)
FPPI	0.867

Tabel 6: Prestatie-metrics voor het FPGA-gebaseerde geïmplementeerde voetgangersdetectie-algoritme.

Tabel 6 hierboven beschrijft dus de nauwkeurigheid van het voetgangersdetectie-algoritme via de verschillende prestatie-metrics: precisie, herinnering, F1-score en FPPI, wanneer het algoritme op het hardwareplatform wordt geïmplementeerd.

Prestatievergelijking met bestaande FPGA-gebaseerde HoG-implementaties
Ten slotte kan het uitgevoerde werk worden vergeleken met de eerdere literatuur om eventuele significante bijdragen van dit onderzoek te vermelden. Deze vergelijking is weergegeven in Tabel 7^{15, 16, 17, 21, 24}hieronder. De artikelen waarmee de vergelijking wordt uitgevoerd zijn allemaal gebaseerd op voetgangersdetectietoepassingen geïmplementeerd op FPGA-platforms, en de algoritmen die voor deze detecties worden gebruikt zijn ook voor alle gelijke, namelijk HoG gecombineerd met een classifier, die ofwel een Adaboost-classifier of SVM is. De beeldgrootte is ook hetzelfde voor elk (640 × 480). De vergelijking wordt gemaakt op basis van parameters zoals de klokfrequentie die de snelheid beïnvloedt, de frames per seconde, het energieverbruik en het gebruik van middelen in termen van LUT's, DSP's, geheugen, slices en registers. Om een eerlijke vergelijking te stimuleren, hebben de onderzoeksartikelen die worden overwogen een vergelijkbare beeldresolutie, en om de bronvergelijking te normaliseren wordt elk hulpbrongebruik genormaliseerd door het aantal verbruikte middelen te delen door het totale aantal beschikbare middelen volgens het gebruikte FPGA-bord.

Referentie	Beeldgrootte	FPGA-bord	Klokfrequentie	Frames per seconde (FPS)	Macht	Pixels /klok	LUT's (%)	DSP48's (%)	BRAMs / geheugenbits (%)	Registers/FF (%)
15	640×480	Xilinx Zynq	82,2 MHz	40	-	1	40	2	0	-
24	640×480	Virtex 6	150 MHz	10	19 W		39	53	22	-
16	640×480	Cycloon V	162 MHz	526	9 W	0.99	21	86	100	21
17	640×480	Altera DE2-115	50 MHz	129	3,6 W	-	73	-	72	60
21	640×480	Zync 7000	100 MHz	240	1,6 W	-	13	3	1	10
DIT WERK	640 X 480	Ultra 96 v2	150 MHz	83	2,435W	0.0632	57	35	31	24

Tabel 7: Vergelijking van parameters en prestaties voor implementaties van voetgangersdetectie op FPGA

Zoals te zien is in tabel 7 hierboven, is te zien dat wanneer de implementatie in dit onderzoek wordt vergeleken met eerdere werken, de vergelijkingen aanzienlijke verbeteringen in snelheid laten zien. De FPGA-kaart kan draaien op een klokfrequentie van 150 MHz, wat aangeeft dat de periode voor het voltooien van de volledige taak minder dan 6 ns is. Hoewel sommige eerdere werken aanzienlijk hogere FPS rapporteren, kan door zorgvuldig onderzoek worden geanalyseerd dat dit voordeel ten koste gaat van een hoger energieverbruik en bijna volledig gebruik van bepaalde bronnen. Als het energieverbruik wordt meegenomen dan in dit werk, is het gerapporteerde vermogen ook aan de lage kant en suggereren de resourcebenuttingen dat het verbruik van elke bron iets hoger is dan bij bepaalde implementaties, maar gelijk aan of minder dan 50% (57% LUT's, 35% DSP's en 31% BRAM), wat aanzienlijke ruimte toont voor meer taken in dit ontwerp. Al met al kan worden gesteld dat het werk dat in dit artikel wordt uitgevoerd een evenwichtige afweging bereikt tussen prestaties, energie en middelengebruik. Daarnaast toonde het gepresenteerde werk schaalbare paralleliteit door meerdere IP-blokken zonder de prestatieparameters drastisch te beïnvloeden.

Aanvullend dossier 1: Script_1_train_test.py.Klik hier om dit bestand te downloaden.

Aanvullend dossier 2: Script_2_HLS_hog.cpp. Klik hier om dit bestand te downloaden.

Aanvullend dossier 3: Script_3_HLS_test_bench.cpp. Klik hier om dit bestand te downloaden.

Aanvullend dossier 4: Script_4_HLS_consts.h.Klik hier om dit bestand te downloaden.

Aanvullend dossier 5: Script_5_jupyter_code.txt.Klik hier om dit bestand te downloaden.

Discussion

Deze studie implementeert effectief een realtime voetgangersdetectiesysteem dat gebruikmaakt van het HoG + SVM-algoritme op geavanceerde FPGA-hardware, gebaseerd op Zynq UltraScale+ MPSoC ontwikkelingsbord²⁴. De resultaten geven aan dat het traditionele HoG-algoritme van human detection¹¹ een nauwkeurigheid van bijna 95% behaalt en slechts de helft van de onboard FPGA-bronnen (LUTs, FFs, BRAM, DSP's) gebruikt, waardoor er een enorme capaciteit is om veel meer verwerking te verwerken voor verschillende taken. Wanneer de volledige implementatiemethode wordt geanalyseerd, wordt geconstateerd dat er verschillende kritieke stappen betrokken zijn. Een belangrijke stap is het trainen van het SVM-model 18,19,24 met een geschikte dataset voor effectieve voetgangersdetectie, zodat de gewichten worden geëxtraheerd en gebruikt in de FPGA-programmering. De trainingscode geeft de prestatienauwkeurigheid aan, en de detectiedrempel moet zorgvuldig worden afgestemd via de regularisatieparameter om een nauwkeurigheid van dicht bij 95% te bereiken. De geselecteerde parameters in de training zijn de aangepaste HoG-descriptors met een venstergrootte van 64 x 128, een blokgrootte van 16 x 16, een celgrootte van 8 x 8, en een aantal bins is geselecteerd als 9. Momenteel is de training gegeven op de INRIA-dataset¹¹ met 2416 positieve en 1218 negatieve beelden. De uitbreiding omvat de rotatie van afbeeldingen om de horizontaal gespiegelde versie te verkrijgen. Andere belangrijke toevoegingen, zoals de evaluatie van het model onder omstandigheden van slechte zichtbaarheid of schaalvariaties, zullen in toekomstig werk worden aangepakt om reproduceerbaarheid en robuustheid te waarborgen. De dataset die voor de training wordt overwogen, moet beelden bevatten van voetgangers in verschillende houdingen, en ook beelden bevatten waarin geen voetgangers voorkomen^18,19.

De andere cruciale stap is het maken van het blokdiagram voor het hele systeem, zodat het PS-gedeelte van de FPGA-kaart kan communiceren met het PL-deel. In deze stap moet worden verzekerd dat elk blok geparametriseerd is met de juiste poorten en correct verbonden is met de andere blokken. De tool biedt ook automatische routering met suggesties om de ontwerper te ondersteunen. Een zeer cruciale stap is de adrestoewijzing na het voltooien van het blokdiagram. De geïmporteerde HoG-IP's moeten adressen krijgen toegewezen op basis van hun diepte, en deze adressen mogen niet hetzelfde zijn voor twee IP's. Deze adressen zijn vereist in de pythoncode op de SD-kaart, die het PS-gedeelte van de FPGA-kaart helpt om de adreslocatie in PL te begrijpen waar het toegang toe heeft om de data te lezen/schrijven. De uitdagende stap is dus de ontwikkeling van de interface op het Python-platform, waarbij de gebruiker de invoerbeelden/video's/live camerafeed naar de FPGA kan sturen en het uitvoerbeeld kan tonen met de gedetecteerde voetgangers nadat de verwerkte beelden van de FPGA zijn ontvangen. De Python-code moet worden geschreven met verschillende debuggingberichten zodat tussentijdse resultaten door de ontwerper kunnen worden bekeken, en in geval van storingen kunnen de fouten worden gediagnosticeerd en gecorrigeerd. Er werd enorm veel tijd besteed aan dit onderzoek om een goede interface tussen het PS- en het PL-gedeelte te creëren. Het Python-script voor deze interface kon na meerdere iteraties toegang krijgen tot de data van de HoG-IP's, en het opnemen van meerdere instructies om de tussenresultaten weer te geven, was zeer behulpzaam bij het oplossen en corrigeren van de fouten.

Een waargenomen beperking van de methode is het gebruik van het python-gedeelte om de interface tussen het PS- en het PL-gedeelte van FPGA tot stand te brengen. Hoewel het python-platform de ontwerptijd drastisch heeft verkort, brengt het extra overhead met zich mee die de realtime prestaties beïnvloeden. Het hardwareversnelde systeem voor voetgangersdetectie rapporteerde een doorvoersnelheid van 83 FPS, maar de algehele prestaties van het systeem werden beïnvloed door latentie of werden niet meer responsief tijdens live cameratests door vertragingen veroorzaakt door dataoverdracht tussen het PS- en het PL-deel. Het toekomstperspectief biedt de mogelijkheid om een volledig hardware-versneld systeem te ontwikkelen zonder enige afhankelijkheid van software.

Hoewel er beperkingen zijn zoals hierboven beschreven, draagt het onderzoek aanzienlijk bij omdat het ontwikkelde systeem naadloos kan worden aangepast voor voetgangersdetectie in stilstaande beelden, livebeelden of video-ingangen. Alle drie de methoden vereisen slechts kleine aanpassingen aan de Python-code op het Jupyter-platform, wat de snelle aanpassingsvermogen van het systeem aan verschillende scenario's aantoont. De resultaten geven aan dat de implementatie op de geavanceerde FPGA-architecturen bemoedigende resultaten oplevert, omdat de prestatieparameters sterk geoptimaliseerd zijn, wat resulteert in goede en acceptabele waarden. De bereikte klokfrequentie is vergelijkbaar met eerdere literatuur ^{14,15,16,20,23}, wat aangeeft dat de snelheid niet wordt verminderd, terwijl het minimale stroomverbruik suggereert dat er geen verwarmingsproblemen zijn. Daarnaast toont het gebruik van hulpbronnen aan dat alle middelen worden benut met minder dan 50%, wat wijst op aanzienlijk potentieel voor verdere ontwerpverbeteringen.

Het ontwikkelde systeem kan worden gebruikt in elke toepassing die de taak vereist om mensen te detecteren en kan worden aangepast voor realtime toepassingen. Ook kunnen toekomstige inspanningen zich richten op het wegnemen van de genoemde beperkingen door het hele systeem volledig op het PL-gedeelte te ontwikkelen, waarbij de FPGA-logica zelf de invoerbeelden leest en de verwerkte uitvoerbeelden weer toont, aangezien bijna 50% van de onboard-resources nog beschikbaar is. Ook als de PS- en PL-integratie wordt gebruikt, kan interfaceontwikkeling worden uitgevoerd via Software Development Kit (SDK) tools. Andere mogelijke uitbreidingen kunnen het identificeren van voetgangers zijn onder aanzienlijk zwaardere weersomstandigheden of bij slecht zicht, of het identificeren van de verstopte voetgangers die achter andere objecten verborgen zitten, waardoor aanpassingen aan het algoritme noodzakelijk zijn. De enige aanpassing die in deze gevallen nodig is, is het vervangen van de door SVM getrainde gewichten na de juiste training volgens de geselecteerde uitdaging, en de rest van het systeem vereist geen andere aanpassingen. Het geïmplementeerde systeem is dus goed geschikt om zich gemakkelijk aan te passen aan andere uitdagende scenario's. Een ander toekomstperspectief zou kunnen zijn om zich te richten op het integreren van extra functies in het systeem om een volledig autonoom voertuig te creëren met behulp van het geavanceerde FPGA-bord.

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
Python	Python	Version 3.10
Ultra 96 V2 FPGA Board	Xilinx	Introduced in 2018	Hardware Implementation Platform used for implementing the pedestrian detection algorithm
Vivado	AMD	2019.2	FPGA Programming tool used for programming the Ultra 96 v2 FPGA board with the pedestrian detection algorithm
Vivado HLS	AMD	2019.2	High Level Synthesis Tool used for high level programming of the pedestrian detection code in the paper to export the Intellectual Property (IP)