Entwurf und Implementierung eines vor Ort programmierbaren Gate-Array-basierten Fußgängererkennungs-Frameworks für autonome Fahranwendungen

Summary

Dieser Forschungsartikel demonstriert die Implementierung eines Echtzeit-Fußgängererkennungsalgorithmus auf feldprogrammierbarer Gate-Array-Hardware, hauptsächlich für autonome Fahranwendungen. Der Algorithmus kombiniert das Histogramm der orientierten Gradienten (HoG) mit einem Support Vector Machine (SVM)-Klassifikator, und die Ergebnisse zeigen Effizienz hinsichtlich Geschwindigkeit, Energieverbrauch und Ressourcennutzung.

Abstract

Autonomes Fahren bietet eine vielversprechende Möglichkeit, die steigende Zahl der Todesfälle durch Verkehrsunfälle zu bewältigen. Ein autonomes Fahrzeug verfügt über viele Funktionen, aber die Fähigkeit, Fußgänger zu erkennen, ist entscheidend, herausfordernd und relevant für verschiedene Echtzeitsituationen wie Überwachung, Personenverfolgung und Überwachung. Die genaue Identifizierung von Fußgängern ist schwierig, da sie in unterschiedlichen Formen, Positionen und Haltungen erscheinen können. Sie können verschiedene Arten von Kleidung tragen und manchmal teilweise verborgen sein oder sich mit nahegelegenen Objekten vermischen. Dieses Papier konzentriert sich auf die Echtzeiterkennung von Fußgängern für selbstfahrende Autos mithilfe einer beliebten Hardware-Plattform: dem Field Programmable Gate Array (FPGA), Ultra 96 v2. Die Studie implementiert eine Methode zur Fußgängererkennung, die auf einem Histogramm der orientierten Gradienten (HOG) kombiniert mit einem Support Vector Machine (SVM)-Klassifikator basiert, um Personen auf dem FPGA-Board zu erkennen und dabei High-Level Synthesis (HLS)-Tools zu nutzen. Die Wirksamkeit des Systems wurde sowohl auf Standbildern als auch auf Live-Videos getestet. Die Ergebnisse zeigen, dass fortschrittliche FPGA-Boards wie das Ultra 96 v2 die Leistungskennzahlen deutlich verbessern. Das System arbeitet mit einer Taktfrequenz von 150 MHz, verbraucht weniger als die Hälfte der verfügbaren Ressourcen und verbraucht etwa 2,5 W Leistung. Außerdem meldet das System eine Fußgängererkennungsgenauigkeit von fast 95 % sowie weitere effiziente Kennzahlen zur Erkennungsbewertung, wie Präzision (78,6 %), Rückruf (88,3 %) und F1-Wert (83,1 %). Zusammenfassend lässt sich sagen, dass das entwickelte System Fußgänger in Echtzeit erkennen kann und das Potenzial hat, die Entwicklung einer intelligenten und sicheren Transportumgebung erheblich zu verbessern.

Introduction

Stadtentwicklung und das Entstehen von Smart Cities sind weltweit interessante Themen. Alle Nationen arbeiten an der Entwicklung ihrer Städte, die so gebaut werden können, dass sie für die Menschen, die dort leben, sicher und komfortabel sind ^1,2. Doch in der aktuellen Situation wurde festgestellt, dass mit wachsender Bevölkerung und zunehmendem Straßenstau die Todesrate durch Verkehrsunfälle durch Fahrlässigkeit und schlechte Sichtprobleme alarmierend ansteigt. Eine vielversprechende Lösung für diese Probleme ist das Aufkommen autonomer Fahrzeuge weltweit, was die Innovation ^1,2,3,4 ausgelöst hat, und Forscher bemühen sich, vollautonome Fahrzeuge zu entwickeln, die es den Fahrgästen ermöglichen, sich ohne Sorgen zu entspannen. Der Bedarf an der Entwicklung autonomer Fahrzeuge rührt daher, dass selbst erfahrene Fahrer durch schlechtes Wetter mit Stress, Dilemmata, Müdigkeit oder Schwierigkeiten bei der Wahrnehmung ihrer Umgebung konfrontiert sein können, und all diese Probleme führen zu Verkehrsunfällen. Ein selbstfahrendes Fahrzeug ist darauf ausgelegt, Unfälle während der Fahrt zu vermeiden, den Motorenverbrauch zu optimieren und die Verkehrsregeln einzuhalten, was^{den Transport zweifellos} verbessern ^wird. Ein autonomes Fahrzeug ist mit mehreren Funktionen, Sensoren und Funktionen ausgestattet, die es ermöglichen, seine Umgebung sehr präzise zu erfassen und Kollisionen und Unfälle zu vermeiden, weshalb es sich nun als vielversprechende Lösung herauskristallisiert, um den Transport sicher und geschützt ^zu machen^.

Unter allen Funktionen, die in ein autonomes Fahrzeug integriert sind, ist eine der wichtigsten die Fußgängererkennung. Ein robustes Fußgängererkennungssystem kann erheblich dazu beitragen, die Todesfälle bei Verkehrsunfällen^{um 5,6,7,8} zu senken, da die Mehrheit der Opfer dieser Unfälle Fußgänger sind. Die Fußgängererkennung besteht darin, Personen auf der Straße zu identifizieren und Kollisionen mit ihnen zu vermeiden. Diese Funktion ist nicht nur für selbstfahrende Autos von Vorteil, sondern auch für verschiedene andere Anwendungsbereiche wie Menschenmengenüberwachung, Personenidentifikation und Tracking^{von 9,10,11.} Der Schlüsselaspekt dieses Erkennungsprozesses ist die Geschwindigkeit und Genauigkeit der Erkennung. Es ist entscheidend, Fußgänger genau und schnell zu erkennen, damit die Reaktionszeit minimal ist. Die Fußgängererkennung stellt eine enorme Herausforderung dar. Fußgänger auf der Straße können jede Kleidung, jedes Aussehen oder jede Haltung tragen und aufgrund schlechten Wetters oder Verdeckung unsichtbar sein 10,11,12,13,14. Außerdem ist es durchaus möglich, dass Fußgänger die Regeln selbst nicht befolgen, und man kann die menschliche Natur nicht kontrollieren, daher ist der beste Ansatz, das Fahrzeug mit der Intelligenz auszustatten, um mit Fehlverhalten umzugehen und Todesfälle zu vermeiden. Der vollständige Arbeitsablauf dieser Forschung und die Motivation hinter der Hardware-Implementierung der Fußgängererkennung lassen sich leicht in Abbildung 1 nachvollziehen, die den Bedarf an Fußgängererkennung, deren verschiedene Anwendungsbereiche, die damit verbundenen Herausforderungen und die Implementierung auf einem FPGA zur Nutzung der angebotenen Vorteile erklärt.

Abbildung 1: Fußgängererkennung. Der Bedarf an Fußgängererkennung, wichtige Anwendungsbereiche der Fußgängererkennung, die Herausforderungen bei der Fußgängererkennung und der Ablauf der Fußgängererkennung auf einem FPGA-Board. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Zur Identifizierung von Fußgängern auf der Straße existieren zahlreiche Algorithmen. Diese Gesamtaufgabe lässt sich hauptsächlich in zwei Hauptteilaufgaben unterteilen: Der erste Schritt extrahiert Merkmale aus einem Eingabebild, behält nur diejenigen bei, die relevant sind und relevante Informationen vermitteln, während die redundanten ignoriert werden. Für eine effektive Erkennung von Menschen oder Fußgängern in einem Bild ist es entscheidend, dass diese Merkmale auf das Vorhandensein einer menschlichen Figur in der Szene^13,14 hinweisen. Nach dieser Extraktion müssen die Merkmale an einen Klassifikator gesendet werden, der bestimmen kann, ob die identifizierten Merkmale einem Menschen entsprechen. Daher benötigt der Algorithmus eine Phase der Extraktion und Beschreibung von Merkmalen, gefolgt von einem Klassifikationsschritt, um die Präsenz von Fußgängern in der Eingabeszene zu bestimmen. Für diesen Zweck stehen verschiedene Algorithmen zur Verfügung. Die bisher am weitesten verbreitete Methode zur Fußgängererkennung bleibt jedoch die Kombination des Histogramms der orientierten Gradienten (HoG) mit dem Support Vector Machine (SVM)-Klassifikator 12,13,14,15. Es gibt zahlreiche Beispiele für Softwareentwicklungen, aber letztlich ist das Ziel, die Implementierung auf eine kompatible Hardwareplattform zu portieren, die dann in das Anwendungssystem integriert werden kann, um in Echtzeit genutzt zu werden. Daher liegt der aktuelle Schwerpunkt auf der Hardware-Realisierung. Es kann daher festgestellt werden, dass eine geeignete Hardware-Implementierung von Fußgängererkennungssystemen entwickelt werden muss, bei der Kameras mit entsprechender Hardware an Fahrzeugen eingesetzt und Fußgänger auf der Straße identifiziert werden können. Wenn man prüft, welche Hardware für solche Implementierungen geeignet ist, ist eine der am häufigsten genutzten Optionen das feldprogrammierbare Gate-Array (FPGA), da es zahlreiche Vorteile bietet, darunter reduzierte Designzeit, Skalierbarkeit, einfache Modifikationen, Rekonfigurierbarkeit sowie geringeren Energie- und Stromverbrauch 15,16,17,18,19,20,21.²².

FPGA-Platinen haben sich kontinuierlich weiterentwickelt und werden heute weit verbreitet für komplexe, fortschrittliche Computer-Vision-Anwendungen verwendet, die von grundlegender Bildverarbeitung über Objekterkennung, Augmented Reality bis hin zu Deep Learning^reichen. Derzeit bieten mehrere leistungsstarke FPGA-Karten außergewöhnliche architektonische Fähigkeiten, um die umfangreiche Verarbeitung für diese komplexen Anwendungen zu bewältigen. Wenn die fortschrittlichen Funktionen autonomer Fahrzeuge, wie Fußgängererkennung, auf solchen Hardwareplattformen implementiert sind, können diese Plattformen für die schnelle Prototypenentwicklung zur Leistungsanalyse sehr nützlich sein, und nach der Optimierung kann der implementierte Algorithmus auf tatsächliche integrierte Schaltkreise übertragen werden, um in das System integriert zu werden.

Seit über einem Jahrzehnt gibt es bedeutende Veröffentlichungen zur Implementierung der Fußgängererkennung mit der HoG- und SVM-Methode auf verschiedenen FPGA-Plattformen. Tabelle 1 fasst die Artikel in diesem Bereich im Zeitraum von 2015 bis 2025 zusammen: 15,16,17,18,19,20,21,22,22,23,24 und konzentriert sich dabei auf die wichtigsten Faktoren wie Bildauflösung, Durchsatz oder Bildrate pro Sekunde (FPS), den Typ des Klassifikators und die wichtigsten Hervorhebungen oder Beiträge der Papier.

Referenz	FPGA-Plattform	Bildauflösung	Klassifikator	Wichtige Höhepunkte / Beiträge
15	Xilinx Zynq	640×480	AdaBoost	Echtzeit-FPGA-Implementierung; ressourceneffizient; verwendet binarisierung zur Optimierung; Gute Erkennungsgenauigkeit.
16	Terasics DE1-SOC-Board	640×480	SVM	Hochleistungs-HOG-Extraktor; integriert SVM; Einzel-Skalen-Erkennung; Pipeline mit niedriger Latenz.
17	Altera DE2-115	640×480	AdaBoost	Bewertet die Leistung aus mehreren Blickwinkeln; FPGA-Implementierung von HOG+AdaBoost; Echtzeit-Fußgängererkennung.
18	Intel Stratix V	640×480	SVM	Mehrfache Fußgängererkennung; FPGA-freundliche HOG+SVM-Pipeline; hebt Kompromisse zwischen Genauigkeit und Hardwareeffizienz hervor.
19	Zynq UltraScale+ MPSoC	3840×2160	SVM	Echtzeit-UHD-Verarbeitung; pipelined HOG+SVM; SoC-FPGA-Implementierung; Fixpunktoptimierung; skalierbare Architektur.
20	Nicht spezifiziert	Nicht spezifiziert	SVM	Erreicht >95 % Erkennungsgenauigkeit; Echtzeit-FPGA-Implementierung; nutzt Parallelität; detailliertes HOG+SVM FPGA-Design zur Fußgängererkennung.
21	Zync 7000 FPGA	1920×1080	SVM	Hochdurchsatz-Stream-Architektur für HOG+SVM; unterstützt HD-Auflösung; effiziente Pipeline für FPGA-Beschleunigung.
22	Ultra96 (rev1)	240×320	SVM	FPGA-Implementierung mit HLS; erkennt rote Ampeln; berechnet Wahrscheinlichkeiten in 891 Regionen; Die Latenz liegt zwischen 153.838 und 19 Zyklen.
23	Xilinx Zynq-7000 FPGA	640 × 480	HOG + SVM	Fußgängererkennung mit HOG-SVM auf FPGA implementiert, wodurch Echtzeitleistung mit reduziertem Stromverbrauch im Vergleich zur CPU-Verarbeitung erreicht wurde. Demonstrierte optimierte Feature-Extraction-Pipeline, die für Embedded Vision-Anwendungen geeignet ist.
24	Xilinx Virtex-6 FPGA	640 × 480	Fixpunktobjektdetektor (Haar-ähnliche Merkmale)	Vorgeschlagene Hochdurchsatz-FPGA-Beschleunigung der Objekterkennung mittels Festpunktarithmetik, um die Rechenkosten zu senken und gleichzeitig die Genauigkeit zu erhalten. Zeigte eine Beschleunigung von 15 × gegenüber CPU-Implementierungen bei effizienter Hardware-Ressourcenauslastung.

Tabelle 1: Literaturübersicht zu Forschungsergebnissen zur Fußgängererkennung bei FPGA (2015–2025).

Tabelle 1 fasst zusammen, dass es umfangreiche Literatur im Bereich der Fußgängererkennung gibt und die Implementierung von Hardware für Forscher von Interesse ist. Es ist auch offensichtlich, dass es fortschrittliche Deep-Learning- und Machine-Learning-Techniken gibt, wie Detektoren auf Basis von Faltungsneuralen Netzen (CNNs) wie YOLO, transformatorbasierte Architekturen usw. für die Aufgabe der Fußgängererkennung. Sie übertreffen sogar den traditionellen HoG-Algorithmus in Bezug auf die Genauigkeit, aber wenn man die Hardware-Implementierung betrachtet, führen die fortschrittlichen Algorithmen zu einer enormen Ressourcenauslastung^23,24 aufgrund der Komplexität des Algorithmus, die auch andere Leistungsparameter beeinflussen können, und es wurde auch beobachtet, dass aufgrund der zusätzlichen Komplexität die Geschwindigkeit im Fall des traditionellen HoG-Algorithmus²⁴ etwas besser ist^{. 25}. Es wurde außerdem beobachtet, dass die fortschrittlichen Techniken mehr Energie verbrauchen, wenn sie auf Hardware^24,26 implementiert werden. Das Ziel der in diesem Artikel umgesetzten Arbeit ist es daher, Fußgängererkennung mit dem traditionellen HoG- und SVM-Framework auf FPGA-Hardware durchzuführen und einen günstigen Kompromiss zwischen Genauigkeit, Geschwindigkeit, Ressourcen und Leistung für Echtzeit-Einbettung zu erzielen. Aus Tabelle 1 geht ganz klar hervor, dass bei der Analyse der HoG- und SVM-basierten Arbeiten nur begrenzte Veröffentlichungen das kürzlich eingeführte Zynq UltraScale+ MPSoC (Multi-Processor System On Chip) basierte FPGA-Entwicklungsboard²⁷ genutzt haben, um die Fähigkeiten dieser Boards zu erforschen, da sich diese Boards aus architektonischer Sicht weiterentwickelt haben. und bieten großes Potenzial für die Implementierung hochwertiger Echtzeit-Computer-Vision-Anwendungen. Es gibt nur wenige Publikationen, die das gesamte Fußgängererkennungssystem in Echtzeit auf den FPGA-Boards realisiert haben. Sie haben sich jedoch auf die effiziente Umsetzung oder Verbesserung der Zwischenaufgaben konzentriert. Außerdem basieren die meisten dieser Implementierungen darauf, das gesamte System auf einer FPGA-Platine mittels Hardware-Beschreibungssprachen zu realisieren. Nur wenige haben die Vorteile von High Level Synthesis (HLS)-Tools genutzt, um den Designzyklus zu beschleunigen. Dieses Papier demonstriert das Design und die Implementierung der Echtzeit-Fußgängererkennung auf einem FPGA-Board, das für autonome Fahranwendungen gedeidet ist. Das Papier nutzt das HoG- und SVM-Framework für die Fußgängererkennung auf Standbildern, Videos oder echten Kameraeingängen. Die verwendete Hardware ist eine hochmoderne und kürzlich veröffentlichte FPGA-Platine, die Ultra96 v2, eine fortschrittliche FPGA-Architektur, die eine leistungsstarke Plattform für Computer Vision, Bildverarbeitung, maschinelles Lernen, Edge Computing ^usw. darstellt. Die Ultra96 v2 ist eine Entwicklungsplatte, die eine Arm-basierte AMD Xilinx Zynq UltraScale+ MPSoC²⁷ enthält. Diese Platine umfasst das Verarbeitungssystem (PS)-Segment, das aus ARM-basierten CPU-Kerne besteht, die die Softwareaspekte des Projekts verwalten, sowie das Segment Programmable Logic (PL), das eine anpassbare Hardwarebeschleunigung^ermöglicht. Zusammen erweitern diese Komponenten die Funktionalität eines hybriden Systems, bei dem der PS-Teil die Steuerung und Interaktion mit externen Elementen verwaltet, während der PL-Teil die eigentliche Verarbeitungslogik übernimmt.

Protocol

Das in dieser Forschung verwendete Implementierungsverfahren, das auf Fußgängererkennung mit HoG + SVM auf einer FPGA-Platine basiert und die Vorteile der Hochstufensynthese nutzt, ist in Abbildung 2 unten dargestellt.

Abbildung 2: Entwurfsverfahren zur Implementierung der Fußgängererkennung auf der FPGA-Platine. Phase 1: Fußgängererkennungsalgorithmus mit HoG+SVM auf dem HLS-Tool und Erzeugung eines IP-Blocks. Phase 2: Fußgängererkennungsalgorithmus mit HoG+SVM für die tatsächliche FPGA-Implementierung und Erzeugung der Bitdatei. Phase 3: Programmierung der Platine mit der generierten Bitdatei. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

1. Fußgängererkennung mit HoG und SVM im HLS-Tool

1. Laden Sie die Python Integrated Development Environment (IDE) herunter, abhängig von den Systemeigenschaften, auf denen der Download durchgeführt wird.
   HINWEIS: In diesem Werk wird die Version Python 3.10 verwendet.
2. Führe ein Python-Skript aus, um ein Trainingsmodell mit dem HoG-Algorithmus und dem SVM-Klassifikator auszuführen. Beginnen Sie das Skript damit, die positiven und negativen Proben aus dem Datensatz zu laden.
   HINWEIS: Verwenden Sie den INRIA-Datensatz¹¹.
3. Entnehmen Sie die HoG-Merkmale für eine Fenstergröße von 64 x 128.
4. Teile die Trainings- und Testdaten aus dem INRIA-Datensatz auf ein Verhältnis von 80/20 auf, mit zufälligem Mischen zur Reproduzierbarkeit.
   HINWEIS: Der Datensatz wird zufällig mit der Python-Funktion gemischt, bevor die Daten aufgeteilt werden. Um die Reproduzierbarkeit sicherzustellen, sodass jedes Mal, wenn ein Seed-Wert im Code fixiert wird, die gleiche Aufteilung erfolgt.
5. Trainieren Sie mit der C-Support Vector Classification (SVC) SVM mit einem linearen Kernel.
6. Extrahieren Sie die Gewichtsvektoren und die Verspannungen.
7. Speichere die SVM-Gewichte und die Verzerrung im Fixpunkt-Q8.8-Format für die FPGA-Implementierung.
   HINWEIS: Die Umrechnung erfolgt, indem die Originalität jedes Gleitkommawerts um den Faktor 256 (2,⁸) skaliert und das Ergebnis in eine ganze Zahl umgesetzt wird.
8. Teste das trainierte Modell mit einem anderen Python-Skript und passe den Regularisierungsparameter C an, bis die Genauigkeit auf mehr als 95 % berechnet wird.
   HINWEIS: Optimierter Regularisierungsparameter erhalten: C = 0,05.
9. Öffne das HLS-Tool und erstelle ein neues Projekt mit der Teilenummer xczu3eg-sbva484-1-e.
10. Schreibe einen Fußgängererkennungscode auf dem hochstufigen Synthesetool mit hochstufigen Sprachen wie C++.
11. Im Code schreiben Sie drei verschiedene C++-Skripte: eines für den HoG-Feature-Deskriptor und den SVM-Klassifikator, eines für den Testbench, um Eingaben für die Testbilder bereitzustellen und die Ausgabebilder zu speichern, und das dritte für eine Headerdatei, die die im Code verwendeten Parameter angibt.
12. Im Code für die HoG-Feature-Berechnung wird das Bild auf 640 x 480 vergrößert und eine Schiebefenster-Architektur mit einer Fenstergröße von 64 x 128 angewendet. Für jedes Fenster berechnen Sie die Gradientenstärke und -orientierung für jeden überlappenden 8 x 8 Block.
    HINWEIS: Es ist wichtig, das gesamte Bild durch das Schiebefenster-Konzept zu scannen, sodass jeder Bereich des Bildes abgedeckt ist und Fußgänger aller möglichen Größen identifiziert werden.
13. Im anderen Teil desselben Codes für den HoG-Merkmalsbeschreiber werden die berechneten Gradienten an den SVM-Klassifikator weitergegeben. Schreibe den Code, um die Merkmale mit den Gewichten des Klassifikators abzugleichen und sie mit der Schwelle zu vergleichen, um das erkannte Merkmal als das eines Menschen zu klassifizieren oder nicht.
14. Klicken Sie im HLS-Tool auf Run C Simulation , um den Code mit Hilfe einer Testbank zu simulieren und die Funktionalitätskorrektheit des Codes zu überprüfen.
15. Stellen Sie verschiedene Eingabebilder für den Code bereit und überprüfen Sie die Ausgabebilder mit den erkannten Fußgängern.
16. Klicken Sie auf Run C Synthese, um den Code zu synthetisieren, den Code mit Hardwaresprachen durch das Tool abzubilden und die Berichte über Timing und Nutzung zu generieren.
    HINWEIS: Das Tool öffnet automatisch die HLS-Syntheseberichte. Dieser Bericht zeigt die Schätzung der erforderlichen Taktfrequenz für die Implementierung der codierten Aufgabe auf der ausgewählten FPGA-Plattform und liefert außerdem eine Schätzung der genutzten Ressourcen. Diese gemeldeten Werte sind lediglich Schätzungen, und die tatsächlichen Parameter werden erst nach der Implementierung auf der FPGA-Platine berechnet.
17. Klicken Sie auf RTL exportieren , um den Intellectual Property (IP)-Block für den HoG-Algorithmus zur Fußgängererkennung zu exportieren.
    HINWEIS: Diese IP soll in späteren Phasen der Implementierung verwendet werden.

2. Programmierung der FPGA-Platine

1. Öffne das Tool für FPGA-Programmierung und erstelle ein neues Projekt. Wählen Sie die Teilenummer als xczu3eg-sbva484-1-e aus und erstellen Sie ein neues Blockdesign.
   HINWEIS: Dieses Blockdiagramm wird erstellt, um die Integration zwischen dem PS- und dem PL-Teil der FPGA-Platine herzustellen. Das verwendete Kommunikationsprotokoll ist das Advanced eXtensible Interface (AXI)-Protokoll.
2. Suche im Tool nach dem IP-Katalog und öffne ihn, sobald du ihn findest.
3. Erstelle ein Benutzerrepository, indem du den Pfad der exportierten RTL-IP in Schritt 1.17 hinzufügst.
4. Im neuen Blockdesignfenster klickt man jetzt mit der rechten Maustaste und wählt IP hinzufügen. Alle IPs werden sichtbar sein, einschließlich derjenigen, die vom Tool bereitgestellt werden, sowie der vom Nutzer hinzugefügten Repositories.
5. Füge den Zync Ultrascale PS-Block aus dem Repository hinzu.
   HINWEIS: Dieser Block spiegelt den PS-Teil des Systems wider, der für die Erzeugung der erforderlichen Taktfrequenzen verantwortlich ist, und verfügt außerdem über Master- und Slave-Ports für die Verbindung zur importierten HoG-IP über den AXI-Interconnect-Block, der auf den AXI-Protokoll-Fundamenten basiert.
6. Fügen Sie 8 HoG-IPs hinzu, da das System 8 Fenster gleichzeitig verarbeitet, um den Vorteil der Parallelität durch die FPGA-Platine zu nutzen.
7. Fügen Sie einen Reset-Block für das Prozessorsystem hinzu, der ebenfalls die Takt- und Reset-Versorgung für jeden einzelnen Block im Diagramm steuert.
8. Füge zwei axi_smart Connect-Blöcke hinzu, um die HoG-IPs mit dem Zync PS-Block zu verbinden. Das gesamte Blockdiagramm mit den vollständigen Verbindungen ist in Abbildung 3 dargestellt.
   HINWEIS: Wie in Abbildung 3 dargestellt, wurden alle Blöcke, die zum Design hinzugefügt werden müssen, deutlich dargestellt. Abbildung 3 ist vom Werkzeug erfasst und zeigt die internen Ports jedes Blocks sowie die Verbindungen zwischen den Ports verschiedener Blöcke. Dieser Block ist das Hauptdesign, da er für die Einrichtung der Schnittstelle zwischen dem PS- und dem PL-Teil der FPGA-Platine verantwortlich ist.
9. Nachdem Sie die Verbindungen gemäß Abbildung 3 abgeschlossen haben, klicken Sie auf Validate Design.
   HINWEIS: Die Validierung prüft im Grunde die fehlenden oder unterbrochenen Verbindungen, was in späteren Phasen zu Problemen führen kann.
10. Klicken Sie auf Synthese und dann Implement Design im tool , nachdem die Validierung des Blockdiagramms erfolgreich ist.
    HINWEIS: Synthesis kartiert das entworfene Blockdiagramm und legt es auf die FPGA-Platine. Dieser Schritt meldet alle Verstöße, die darauf hindeuten könnten, dass das Design nicht auf Hardware implementiert werden kann.
11. Das Tool erstellt außerdem Berichte zu Zeit, Ressourcenverbrauch und Stromverbrauch. Prüfen Sie die Berichte sorgfältig, um auf Zeitverstöße zu achten, und analysieren Sie die Leistung des entworfenen Systems.
12. Klicken Sie auf Generate the Bitstream File , was die .bit-Datei erzeugt, die zur Programmierung der FPGA-Platine benötigt wird.

Abbildung 3: Blockdiagramm zur Fußgängererkennung mit HoG + SVM importierter IP. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

3. Endgültige Implementierung auf der FPGA-Platine

1. Nimm die FPGA-Platine und setze die SD-Karte mit der passenden Bilddatei in den Steckplatz der Platine.
2. Schließen Sie das Board auch mit dem Computer an.
3. Starte die FPGA-Platine im SD-Kartenmodus, um Python-Programmierung darauf zu aktivieren^21,22.
4. Greifen Sie auf die Jupyter-Plattform auf dem Board zu, nachdem Sie sie mit dem WLAN verbunden haben.
5. Verbinden Sie eine Webcam mit der Platine.
6. Schreibe einen Python-Code, um die generierte Bitdatei zu importieren und die Aufgabe zu übernehmen, auf die Kamerabilder zuzugreifen.
7. Im Code wird das Skript so geschrieben, dass das Bild über den PS-Teil im Speicher der FPGA-Platine geschrieben und zur Verarbeitung an das PL-Teil weitergeleitet wird.
   HINWEIS: Der PL-Teil der Platine, der den HoG-IPs entspricht, greift über diese Speicherpositionen auf die Bildpixel zu, verarbeitet sie und liefert die Ergebnisse als Ausgabe.
8. Schreibe geeigneten Code im selben Python-Skript, um die verarbeiteten Bilder zu lesen und auf dem Computerbildschirm anzuzeigen.
   HINWEIS: Damit ist das gesamte Design abgeschlossen und das System ist nun bereit für den Einsatz in realen Anwendungen. Alle in dieser Studie verwendeten Codes werden als ergänzende Codierungsdateien hochgeladen (Supplementary File 1 [Script_1_train_test.py], Supplementary File 2 [Script_2_HLS_hog.cpp], Supplementary File 3 [Script_3_HLS_test_bench.cpp], Supplementary File 4 [Script_4_HLS_consts.h], Supplementary File 5 [Script_5_jupyter_code.txt]).

Results

Implementierung der Fußgängererkennung auf HLS
Abbildung 4 zeigt die Simulationsergebnisse auf dem HLS-Tool zur Fußgängererkennung mit HoG + SVM. Ein Eingabebild mit einem Fußgänger wird als Testeingabe für den Code eingespeist, und die Ausgabe mit den erkannten Fußgängern wird angezeigt. Im Bild gibt es zwei Abschnitte. Die erste Erkennung hat immer wieder viele Begrenzungsboxen um denselben Fußgänger, und im zweiten Bild werden die überlappenden Boxen entfernt und unterdrückt, sodass nur noch die Hauptdetektionsboxen übrig bleiben.

Abbildung 4: Simulationsergebnis mit dem HLS-Werkzeug. (A,B) Zwei verschiedene Eingabebilder und die resultierenden Bilder mit den erkannten Fußgängern. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Das HLS-Tool liefert außerdem Syntheseberichte zum Zeitpunkt und zur Ressourcennutzung. Die Zeitübersicht hebt den vom Design geforderten Zeitraum hervor und liefert die maximalen und minimalen Latenzwerte in Bezug auf die Anzahl der Zyklen. Diese Informationen sind nützlich, um abzuschätzen, wie viel Zeit das Design für die Ausführung benötigt und wie hoch die Taktfrequenz sein sollte, wenn man zur eigentlichen Hardware-Implementierung wechselt. Tabelle 2 unten zeigt den Zeitbericht nach der HLS-Synthese, der klar zeigt, dass die Ziel-Taktzeit 6 ns betrug und das Design 5,25 ns benötigte, was weniger als das Ziel ist, sodass der Zeitraum 6 ns oder höher, aber nicht unter 5 ns liegen kann.

Zeitübersicht
Uhr	Ziel	Geschätzt
	6,00 ns	5,250 ns
Nutzungszusammenfassung
	Gesamt / Verfügbar	Prozentsatz der Nutzung
BRAM18K	22 / 432	5%
DSP48E	13 / 360	3%
FF	5611/ 141120	3%
LUT	9904/ 70560	14%
URAM	0	0

Tabelle 2: Geschätzter Zeit- und Ressourcenauslastungsbericht vom HLS-Tool zur Fußgängererkennung mittels HoG-SVM.

Tabelle 2 zeigt außerdem den Auslastungsbericht. Es zeigt die prozentuale Auslastung wichtiger Onboard-FPGA-Ressourcen entsprechend der ausgewählten Zielplatine. Für dieses Fußgängererkennungsdesign zeigt der Nutzungsbericht, dass das Design 14 % der Nachschlagtabellen (LUTs), 3 % der Flip Flops (FFs), 3 % der digitalen Signalverarbeitung (DSP) und 5 % des Block Random Access Memory (BRAM) verbraucht. Diese Schätzungen sind nicht die exakten Nutzungsberichte, aber die tatsächlichen Berichte liegen nahe an diesen Schätzungen. Dies sind nur die Schätzungen, die von den HLS-Tools berechnet werden können. Die tatsächliche Umsetzung unterscheidet sich in der Regel stark von diesen Schätzungen.

Tatsächliche Implementierungsergebnisse durch Hardwareprogrammierung
Nachdem der Code in eine IP abgebildet wurde, die im FPGA-Programmierwerkzeug importiert und das Design auf der tatsächlichen FPGA-Hardware implementiert wurde, werden auch mehrere Berichte generiert. Die erste ist die Zeitzusammenfassung, die zeigt, ob die dem Design bereitgestellte Taktfrequenz ausreicht oder nicht. Wenn alle Zeitvorgaben erfüllt sind und keine Verstöße vorliegen, kann das Design fortgesetzt werden. Tabelle 3 unten zeigt die vom Tool generierte Zeitübersicht. Wie in der Tabelle dargestellt, zeigt die Zeitübersicht die größte negative Slack, nämlich 4,073 ns. Da dieser Wert positiv ist, deutet er darauf hin, dass noch so viel Zeit zur Verfügung steht. Negative Werte zeigen an, dass der FPGA länger benötigt, um die Aufgabe zu erledigen, und die Uhr läuft schnell. Da es in diesem Fall keine negativen Werte gibt, was bedeutet, dass die Zeitvorgaben erfüllt sind.

Zusammenfassung des Entwurfszeitpunkts
Aufbau	Halt	Pulsbreite
Schlimmster negativer Slack: 4,073 ns	Schlechteste Halteslack: 0,010 ns	Schlechteste Pulsbreite Slack: 3,500 ns

Tabelle 3: Tatsächliche Zeitübersicht für Fußgängererkennung auf der FPGA-Tafel.

Außerdem zeigt das Tool die Ressourcenauslastungsberichte an, also die tatsächliche Auslastung der Onboard-Ressourcen gemäß der ausgewählten FPGA-Platine. In diesem Fall ist die ausgewählte Platine die Zynq UltraScale+ MPSoC (Multi-Processor System On Chip) basierte FPGA-Entwicklungsplatine²⁷. Tabelle 4 unten zeigt die Ressourcennutzung und Abbildung 5 zeigt die diagrammatische Darstellung der Ressourcennutzung.

Die Nutzungszusammenfassung zeigt den tatsächlichen Verbrauch der Bordressourcen an, da 8 HoG-IPS parallel verwendet werden und die von der HLS-Synthese gemeldeten Schätzungen für ein einzelnes HoG-IP bezogen wurden. Aber selbst nach so umfangreicher Nutzung liegt der Ressourcenverbrauch jeder Ressource bei weniger als 50 %. Tabelle 4 zeigt klar die Auslastung der verschiedenen Ressourcen und deren Auslastungsprozentsatz, was in Abbildung 5 bildlich dargestellt ist.

Ressource	Nutzung	Verfügbar	Auslastungsprozent
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%

Tabelle 4: Tatsächlicher Nutzungsbericht für Fußgängererkennung auf FPGA-Tafel.

Abbildung 5: Ressourcenauslastung für Fußgängererkennung auf FPGA-Platine nach tatsächlicher Implementierung. Schau dir Tabellen an (LUT): 57 %, LUTRAM: 25 %, Flip-Flops (FF): 24 %, Block-RAM (BRAM): 31 %, Digitale Signalprozessoren (DSP): 36 %, Puffer: 1 %. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Der dritte Bericht betrifft die Leistungsschätzungen der Platine für den Energieverbrauch durch das Design. Abbildung 6 unten zeigt den Stromverbrauchsbericht, der zeigt, dass die gesamte On-Chip-Leistung 2,435 W beträgt. Die Verbindungstemperatur und die von jedem wichtigen Netz und jeder Komponente verbrauchte Leistung werden ebenfalls dargestellt. Die Leistungsmessungen zeigen keinen alarmierenden Stromverbrauch hervor, weshalb das Design als energieeffizient betrachtet werden kann.

Abbildung 6: Leistungsabschätzung für Fußgängererkennung auf der FPGA-Platine nach der tatsächlichen Implementierung. Der von den Werkzeugen erzeugte Strombericht zeigt die insgesamt verbrauchte Leistung mit 2,435 W an und zeigt außerdem die Verteilung der Leistung auf die verschiedenen Ressourcen auf der FPGA-Platine. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Eine weitere Analyse wird durchgeführt, um den Vorteil der Verwendung von 8 HoG-IPs anstelle einer einzelnen HoG-IP oder mehr als 8 im erstellten Blockdiagramm zu verstehen, wie in Abbildung 3 dargestellt. Die hardwarebezogenen Leistungsmetriken wurden sowohl für eine einzelne HoG-IP als auch für 8 HoG-IPs parallel berechnet. Tabelle 5 unten zeigt den Vergleich.

Perfromanzmetrik	1 IP	8 IPs
Timing (ns)	5.312	~5,25
Frequenz (MHz)	188	150
Leistung (W)	1.9	2.43
LUTs	4998	40536
FF / Register	4,031	33,342
DSP	16	128
BRAM	8.5	68
FPS	~10–11	83

Tabelle 5: Vergleich von Leistungskennzahlen unter Verwendung einzelner und mehrerer HoG-IPs.

Tabelle 5 zeigt eindeutig, dass, wenn man die Ressourcen wie LUTs, FFs, DSPs und BRAM betrachtet, dann bei einer einzelnen HoG-IP und 8 HoG-IPs die Skalierung linear ist und die Ressourcen fast achtfach zunimmt. Das ist eindeutig zu erwarten, da mehr IPs zu mehr Ressourcen führen. Außerdem verschlechtert sich die maximale Frequenz leicht um 20 % von 188 MHz auf 150 MHz. Dies ist auch zu erwarten, da mehr Blöcke zu mehr Verbindungen und damit längeren Pfaden führen, was zu einer Zunahme kritischer Pfade führt. Aber die vorteilhaften Faktoren wie Bilder pro Sekunde (FPS) verbessern sich von 10 auf 83, was eine nichtlineare Skalierung im Fall von FPS durch das eingeführte Konzept der Parallelität mit 8 HoG-IPs zeigt. Außerdem skaliert die Leistung von 1,9 W auf 2,4 W, was auf eine verbesserte Energieeffizienz durch Rohrleitungen hinweist. Daher zeigt diese Analyse eindeutig, dass die Einführung von 8 HoG-IPs für das Design vorteilhaft ist und eine Skalierung über 8 hinaus zu einem Überverbrauch von Ressourcen führen kann; daher werden die Anzahl der Blöcke über 8 nicht als günstig angesehen.

Fußgängererkennungsergebnisse nach FPGA-Implementierung
Schließlich wird das gesamte System auf der FPGA-Platine integriert und die Bitstream-Datei generiert, die dann über die SD-Karte programmiert wird, die mit Python-Programmierbarkeitsfunktion gebootet wird. Sobald die Platine mit der SD-Karte gebootet wurde, kann die Jupyter-Schnittstelle aktiviert und Python-Code auf der Plattform geschrieben und ausgeführt werden. Der Python-Code wird ausgeführt und getestet, um Fußgängererkennung auf verschiedenen Eingabebildern zu gewährleisten. Das Ergebnis einiger Bilder ist in Abbildung 7 unten dargestellt. Diese Bilder stammen aus dem INRIA-Datensatz sowie zufällige Bilder von Fußgängern, die aus Open-Source-Online-Quellen^{stammen 26,27}.

Abbildung 7: Fußgängererkennungsergebnisse auf Standbildern über das FPGA-Board. Die getesteten Bilder umfassen Bilder aus dem INRIA-Datensatz, Open-Source-Bilder, die bei Google verfügbar sind, um die Erkennungsgenauigkeit auf überfüllten Straßen Indiens zu testen. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Das System wird außerdem mit Echtzeitbildern durch eine Webcam getestet und die Fußgänger im Bild erkannt; das System wird mit bereits aufgenommenen Videoeingaben von Fußgängern getestet. Die Ergebnisse dafür sind in Abbildung 8 und Abbildung 9 dargestellt. Abbildung 8 zeigt eine Reihe von Beispielbildern, die von der Webcam aufgenommen wurden, sowie die Ergebnisse der Fußgängererkennung in jedem Bild, während Abbildung 9 die Ergebnisse der Fußgängererkennung zeigt, die auf einem dem System bereitgestellten Eingabevideo implementiert wurden.

Abbildung 8: Fußgängererkennungsergebnisse auf einem Bild, das von einer Kamera in Echtzeit über das FPGA-Board aufgenommen wird. Echtzeitaufnahme von Videos mit der Webcam 720 P und Demonstration der Echtzeiterkennung von Fußgängern. Die verschwommenen Bilder entstehen, wenn Schnappschüsse aus dem laufenden Live-Video aufgenommen werden. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Abbildung 9: Fußgängererkennungsergebnisse auf Videos, die als Eingabe für das FPGA-Board bereitgestellt werden. Die Videos stammen aus Open-Source-Links. Bitte klicken Sie hier, um eine größere Version dieser Abbildung anzusehen.

Schätzung von Leistungskennzahlen
Um die Effizienz zu berechnen und die Leistung des oben umgesetzten Designs zu analysieren, ist es unerlässlich, Leistungskennzahlen zu erstellen, die zur Leistungsbewertung nützlich sind. Die Leistungsmetriken zur Erkennung der Effizienz eines Detektionsalgorithmus hängen im Wesentlichen von den Werten von echten Positiven (TP), echten Negativen (TN), Falsch-Positiven (FP) und Falsch-Negativen (FN) ab. Aus diesen Werten können Leistungskennzahlen wie Genauigkeit, Abruf, F1-Wert, Fehlalarme pro Bild und Genauigkeit gemäß den unten angegebenen Gleichungen berechnet werden. Es wurde beobachtet, dass die meisten Forschungsarbeiten ihre Nachweisleistung über den Genauigkeitsparameter angeben. Es wurde jedoch beobachtet, dass die Genauigkeitsberechnung, die die Verwendung von TN beinhaltet, ein irreführender Parameter sein kann, da der Wert von TN nicht korrekt im wahren Sinne berechnet werden kann, da es darum geht, die Anzahl aller Erkennungsfenster in einem Bild zu bestimmen, das keinen Fußgänger zeigt, und der implementierte Algorithmus meldet dies ebenfalls als keine Erkennungen. Diese Zahl ist im Allgemeinen sehr hoch, da die Gesamtzahl der Erkennungsfenster in einem Bild groß ist und die Hintergrundbereiche in jedem Bild meist Regionen ohne Fußgänger entsprechen. Durch genaue Betrachtung der Genauigkeitsformel in den Gleichungen [1] – [5] lässt sich erkennen, dass der Wert von TN im Vergleich zu TP+FP+FN recht hoch ist, sodass der Genauigkeitsparameter meist einen hohen Wert hat. Um die Leistung wirklich zu bewerten, ist es viel besser, Kennzahlen wie Genauigkeit, Abruf und F1-Score anzugeben, die nicht von TN abhängen und daher viel genauer sind.

[1]

[2]

[3]

[4]

[5]

Um die Werte von TP, TN und FN für dieses Paper zu bestimmen, wurde das Experiment mit den Standbildern auf einer riesigen Anzahl von Bildern wiederholt. Aus den Ergebnissen jedes Bildes wurde der Wert der echten Positiven berechnet, also die Anzahl der korrekt erkannten Fußgänger, Fehlalarme, die Anzahl der falsch erkannten Fußgänger und falsche Negative, also die tatsächlichen unentdeckten Fußgänger. Die folgenden Werte wurden nach den durchgeführten Experimenten angegeben und sind in Tabelle 6 unten dargestellt.

Leistungskennzahl	Wert
TP	143
FP	39
FN	19
Genauigkeit	0.786 (78.6%)
Rückruf	0.883 (88.3%)
F1-Ergebnis	0.831 (83.1%)
FPPI	0.867

Tabelle 6: Leistungskennzahlen für den FPGA-basierten implementierten Fußgängererkennungsalgorithmus.

Tabelle 6 oben beschreibt somit die Genauigkeit des Fußgängererkennungsalgorithmus anhand der verschiedenen Leistungskennzahlen: Präzision, Rückruf, F1-Wert und FPPI, wenn der Algorithmus auf der Hardwareplattform implementiert wird.

Leistungsvergleich mit bestehenden FPGA-basierten HoG-Implementierungen
Schließlich kann die durchgeführte Arbeit mit der bisherigen Literatur verglichen werden, um bedeutende Beiträge dieser Forschung zu belegen. Dieser Vergleich ist in Tabelle 7^{15, 16, 17, 21, 24}unten dargestellt. Die Artikel, mit denen der Vergleich durchgeführt wird, basieren alle auf Fußgängererkennungsanwendungen, die auf FPGA-Plattformen implementiert wurden, und die für diese Erkennungen verwendeten Algorithmen sind ebenfalls für alle gleich, nämlich HoG kombiniert mit einem Klassifikator, der entweder ein Adaboost-Klassifikator oder SVM ist. Die Bildgröße ist ebenfalls für beide gleich (640 × 480). Der Vergleich basiert auf Parametern wie der Taktfrequenz, die die Geschwindigkeit, die Bilder pro Sekunde, den Stromverbrauch und die Ressourcennutzung in Bezug auf LUTs, DSPs, Speicher, Slices und Register beeinflusst. Um einen fairen Vergleich zu ermöglichen, haben die zum Vergleich betrachteten Forschungsarbeiten eine ähnliche Bildauflösung, und um den Ressourcenvergleich zu normalisieren, wird jede Ressourcennutzung normalisiert, indem die Anzahl der verbrauchten Ressourcen durch die Gesamtzahl der verfügbaren Ressourcen gemäß dem verwendeten FPGA-Board geteilt wird.

Referenz	Bildgröße	FPGA-Board	Taktfrequenz	Bilder pro Sekunde (FPS)	Macht	Pixel /Uhr	LUTs (%)	DSP48s (%)	BRAMs / Speicherbits (%)	Register/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	Zyklon 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
DIESE ARBEIT	640 x 480	Ultra 96 v2	150 MHz	83	2,435W	0.0632	57	35	31	24

Tabelle 7: Vergleich von Parametern und Leistung für Implementierungen der Fußgängererkennung auf FPGA

Wie in Tabelle 7 oben zu sehen ist, ist zu erkennen, dass im Vergleich der Umsetzung dieser Forschung mit den vorherigen Arbeiten die Vergleiche signifikante Verbesserungen hinsichtlich der Geschwindigkeit zeigen. Die FPGA-Platine kann mit einer Taktfrequenz von 150 MHz laufen, was bedeutet, dass der Zeitraum für die vollständige Aufgabe weniger als 6 ns beträgt. Obwohl einige frühere Arbeiten deutlich höhere FPS melden, lässt sich durch sorgfältige Untersuchung analysieren, dass dieser Vorteil auf Kosten eines höheren Energieverbrauchs sowie einer nahezu vollständigen Nutzung bestimmter Ressourcen einhergeht. Wenn der Stromverbrauch berücksichtigt wird, ist in dieser Arbeit auch die gemeldete Leistung eher niedrig, und die Ressourcennutzung deutet darauf hin, dass der Verbrauch jeder Ressource etwas höher ist als bei bestimmten Implementierungen, aber gleich oder weniger als 50 % (57 % LUTs, 35 % DSPs und 31 % BRAM), was erheblichen Spielraum für weitere Aufgaben in diesem Design zeigt. Insgesamt kann festgestellt werden, dass die in diesem Artikel umgesetzte Arbeit einen ausgewogenen Kompromiss zwischen Leistung, Leistung und Ressourcennutzung erreicht. Darüber hinaus zeigte die präsentierte Arbeit skalierbare Parallelität durch mehrere IP-Blöcke, ohne die Leistungsparameter drastisch zu beeinträchtigen.

Ergänzende Akte 1: Script_1_train_test.py.Bitte klicken Sie hier, um diese Datei herunterzuladen.

Ergänzende Akte 2: Script_2_HLS_hog.cpp. Bitte klicken Sie hier, um diese Datei herunterzuladen.

Ergänzende Akte 3: Script_3_HLS_test_bench.cpp. Bitte klicken Sie hier, um diese Datei herunterzuladen.

Ergänzende Akte 4: Script_4_HLS_consts.h.Bitte klicken Sie hier, um diese Datei herunterzuladen.

Ergänzende Akte 5: Script_5_jupyter_code.txt.Bitte klicken Sie hier, um diese Datei herunterzuladen.

Discussion

Diese Studie implementiert effektiv ein Echtzeit-Fußgängererkennungssystem, das den HoG + SVM-Algorithmus auf fortschrittlicher FPGA-Hardware auf Basis des Zynq UltraScale+ MPSoC Entwicklungsboards²⁴ verwendet. Die Ergebnisse zeigen, dass der traditionelle HoG-Algorithmus der menschlichen Erkennung¹¹ eine Genauigkeit von nahe 95 % erreicht und nur die Hälfte der bordeigenen FPGA-Ressourcen (LUTs, FFs, BRAM, DSPs) nutzt, was eine enorme Kapazität für deutlich mehr Verarbeitung für verschiedene Aufgaben ermöglicht. Wenn der gesamte Implementierungsansatz analysiert wird, wird festgestellt, dass verschiedene kritische Schritte beteiligt sind. Ein wichtiger Schritt besteht darin, das SVM-Modell 18,19,24 mit einem geeigneten Datensatz für eine effektive Fußgängererkennung zu trainieren, sodass die Gewichte extrahiert und in der FPGA-Programmierung verwendet werden. Der Trainingscode zeigt die Leistungsgenauigkeit an, und die Erkennungsschwelle muss sorgfältig über den Regularisierungsparameter abgestimmt werden, um eine Genauigkeit von nahe 95 % zu erreichen. Die im Training ausgewählten Parameter sind die benutzerdefinierten HoG-Deskriptoren mit einer Fenstergröße von 64 x 128, einer Blockgröße von 16 x 16, einer Zellgröße von 8 x 8 und einer Anzahl von Bins, die mit 9 ausgewählt sind. Derzeit wurde das Training auf dem INRIA-Datensatz¹¹ mit 2416 positiven und 1218 negativen Bildern durchgeführt. Die Erweiterung beinhaltet die Rotation von Bildern, um die horizontal gespiegelte Version zu erhalten. Weitere wichtige Einschlüsse, wie die Bewertung des Modells unter Bedingungen schlechter Sichtbarkeit oder Größenunterschiede, werden in zukünftigen Arbeiten zur Sicherstellung von Reproduzierbarkeit und Robustheit behandelt. Der für das Training berücksichtigte Datensatz muss Bilder von Fußgängern in verschiedenen Posen enthalten und auch Bilder enthalten, in denen keine Fußgänger enthalten^{sind 18,19}.

Der andere entscheidende Schritt besteht darin, das Blockdiagramm für das gesamte System zu erstellen, sodass der PS-Teil der FPGA-Platine mit dem PL-Teil kommunizieren kann. In diesem Schritt muss sichergestellt werden, dass jeder Block mit den richtigen Ports parametrisiert ist und korrekt mit den anderen Blöcken verbunden ist. Das Tool bietet außerdem automatisches Routing mit Vorschlägen zur Unterstützung des Designers. Ein sehr wichtiger Schritt ist die Adresszuweisung nach Ausfüllen des Blockdiagramms. Die importierten HoG-IPs müssen entsprechend ihrer Tiefe Adressen zugewiesen werden, und diese Adressen dürfen nicht für zwei IPs gleich sein. Diese Adressen sind im Python-Code auf der SD-Karte erforderlich, der dem PS-Teil der FPGA-Platine hilft, den Adressstandort in PL zu verstehen, auf den er Zugriff hat, um die Daten zu lesen/zu schreiben. Der herausfordernde Schritt ist daher die Schnittstellenentwicklung auf der Python-Plattform, die es dem Benutzer ermöglicht, die Eingabebilder/Videos/Live-Kamera-Feeds an die FPGA zu senden und das Ausgabebild nach Erhalt der bearbeiteten Bilder vom FPGA mit den erkannten Fußgängern anzuzeigen. Der Python-Code muss mit verschiedenen Debugging-Meldungen geschrieben werden, damit der Designer Zwischenergebnisse einsehen kann und im Falle von Fehlern die Fehler diagnostiziert und korrigiert werden können. In dieser Forschung wurde eine enorme Menge Zeit investiert, um eine angemessene Schnittstelle zwischen dem PS- und dem PL-Teil herzustellen. Das Python-Skript für diese Schnittstelle konnte nach mehreren Iterationen auf die Daten der HoG-IPs zugreifen, und die Einbindung mehrerer Anweisungen zur Darstellung der Zwischenergebnisse war sehr hilfreich bei der Fehlerbehebung und Behebung.

Eine beobachtete Einschränkung der Methode ist die Nutzung des Python-Teils zur Einrichtung der Schnittstelle zwischen PS- und PL-Teil von FPGA. Während die Python-Plattform die Designzeit drastisch verkürzt hat, bringt sie zusätzliche Overheads mit sich, die die Echtzeitleistung beeinträchtigen. Das hardwarebeschleunigte Fußgängererkennungssystem meldete einen Durchsatz von 83 FPS, aber die Gesamtleistung des Systems wurde durch Latenz beeinträchtigt oder während Live-Kameratests aufgrund von Verzögerungen durch Datenübertragung zwischen PS und PL unzuverlässig. Die Zukunftsperspektive birgt die Möglichkeit, ein vollständiges, hardwarebeschleunigtes System ohne jegliche Softwareabhängigkeit zu entwickeln.

Obwohl es die oben beschriebenen Einschränkungen gibt, trägt die Forschung erheblich bei, da das entwickelte System nahtlos für Fußgängererkennung in Standbildern, Live-Feeds oder Video-Eingängen angepasst werden kann. Alle drei Methoden erfordern nur geringfügige Änderungen am Python-Code auf der Jupyter-Plattform, was die schnelle Anpassungsfähigkeit des Systems an verschiedene Szenarien demonstriert. Die Ergebnisse zeigen, dass die Implementierung der fortschrittlichen FPGA-Architekturen ermutigende Ergebnisse liefert, da die Leistungsparameter hochoptimiert sind, was zu guten und akzeptablen Werten führt. Die erreichte Taktfrequenz ist vergleichbar mit der früheren Literatur^{14, 15, 16, 20, 23}, was darauf hindeutet, dass die Geschwindigkeit nicht beeinträchtigt wird, während der minimale Stromverbrauch darauf hindeutet, dass keine Heizprobleme vorliegen. Außerdem zeigt die Ressourcennutzung, dass alle Ressourcen mit weniger als 50 % genutzt werden, was auf erhebliches Potenzial für weitere Designverbesserungen hinweist.

Das entwickelte System kann in jeder Anwendung eingesetzt werden, die die Aufgabe erfordert, Menschen zu erkennen, und kann für Echtzeitanwendungen angepasst werden. Zukünftige Bestrebungen könnten sich auch darauf konzentrieren, die genannten Einschränkungen zu beseitigen, indem das gesamte System entweder vollständig auf dem PL-Teil entwickelt wird oder die FPGA-Logik die Eingabebilder selbst liest und die verarbeiteten Ausgaben darstellt, da noch fast 50 % der Onboard-Ressourcen verfügbar sind. Wenn PS- und PL-Integration genutzt werden soll, kann auch die Schnittstellenentwicklung über Software Development Kit (SDK)-Tools durchgeführt werden. Weitere mögliche Erweiterungen könnten die Identifizierung von Fußgängern bei deutlich härteren Wetterbedingungen oder bei schlechter Sicht oder die Identifikation der verdeckten Fußgänger sein, die hinter anderen Objekten verborgen sind, was Änderungen am Algorithmus erforderlich macht. Die einzige Modifikation, die in diesen Fällen erforderlich ist, wäre der Austausch der SVM-trainierten Gewichte nach ordnungsgemäßem Training entsprechend der gewählten Herausforderung, und der Rest des Systems benötigt keine weiteren Modifikationen. Daher ist das implementierte System gut geeignet, um sich leicht an andere herausfordernde Szenarien anzupassen. Eine weitere zukünftige Perspektive könnte darin bestehen, zusätzliche Funktionen ins System zu integrieren, um ein vollständig autonomes Fahrzeug mit der fortschrittlichen FPGA-Platine zu schaffen.

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
Python	Python	Version 3.10
Ultra 96 V2 FPGA-Board	Xilinx	Einführung 2018	Hardware-Implementierungsplattform zur Implementierung des Fußgängererkennungsalgorithmus
Vivado	AMD	2019.2	FPGA-Programmierwerkzeug, das zur Programmierung der Ultra 96 v2 FPGA-Platine mit dem Fußgängererkennungsalgorithmus verwendet wird;
Vivado HLS	AMD	2019.2	Hochstufiges Synthese-Werkzeug, verwendet für die hochstufige Programmierung des Fußgängererkennungscodes im Artikel zum Export des geistigen Eigentums (IP)