High-Performance-Inferenz on Chip FPGAs für Bildverarbeitung mit maschinellem Lernen

Das schnelle Wachstum der von Kameras und anderen Geräten stammenden Datenmengen hat dazu geführt, dass maschinelles Lernen (ML) unter anderem in der Automobil- und Sicherheitstechnik eingesetzt wird. Spezialisierte Geräte versprechen High-Performance-ML-Inferenz in Bildverarbeitungsanwendungen.

Viele dieser Geräte sind noch in den frühesten Entwicklungsstadien und die Entwickler suchen nach den besten Algorithmen, während sich im Bereich der künstlichen Intelligenz (KI) in rasantem Tempo neue Methoden entwickeln.

Heute nutzen Entwickler FPGA-basierte Plattformen für ML zum Erstellen von eingebetteten Bildverarbeitungssystemen, die den gestiegenen Leistungsanforderungen gewachsen sind. Zugleich ist genug Flexibilität möglich, um mit den Fortschritten beim maschinellen Lernen Schritt zu halten.

Bei den ML-Algorithmen haben sich faltungsneuronale Netzwerke (Convolutional Neural Networks – CNNs) als bevorzugte Lösung für die Bildklassifizierung durchgesetzt. Weil sie hohe Genauigkeitsraten in der Bilderkennung erreichen, werden sie in einer Vielzahl von Anwendungen plattformübergreifend für Smartphones, Sicherheitssysteme und Fahrerassistenzsysteme der Automobiltechnik eingesetzt. CNNs sind ein Typ der tiefen neuronalen Netzwerke (Deep Neural Network – DNN) und verwenden als solche eine neuronale Netzwerkarchitektur mit spezialisierten Schichten, die Merkmale aus Bildern extrahieren und diese Merkmale dazu verwenden, beim Training mit beschrifteten Bildern Bilder zu klassifizieren.

CNN-Entwickler führen in der Regel ein Training auf High-Performance-Systemen oder Cloud-Plattformen durch und verwenden Grafikprozessoren (GPUs), um die große Anzahl an Matrixberechnungen, die für das Training von Modellen mit beschrifteten Bilddatensätzen erforderlich sind und oft im Millionenbereich liegen, zu beschleunigen. Nach dem Training wird das trainierte Modell in Inferenzanwendungen verwendet, zur Klassifizierung neuer Bilder oder Frames aus Videostreams. Für Inferenz eingesetzt, muss ein trainiertes Modell immer noch dieselben Matrixberechnungen durchführen, aber weil das Inputvolumen so viel kleiner ist, können Entwickler CNNs für kleinere ML-Anwendungen einsetzen, die auf Universal-Hardware laufen.

Für viele Anwendungen fehlt Universalplattformen jedoch die Leistung, die erforderlich ist, um bei CNN-Inferenz eine hohe Genauigkeit und Leistung zugleich zu erzielen. Optimierungstechniken und alternative CNN-Architekturen wie MobileNet oder SqueezeNet reduzieren die Plattformanforderungen, aber das geschieht in der Regel auf Kosten der Genauigkeit und Inferenzlatenz, was unter Umständen nicht mit den Anwendungsanforderungen vereinbar ist.

Zugleich verkompliziert die rasante Weiterentwicklung der Algorithmen die Entwicklung von ICs für maschinelles Lernen; diese sollten so stark spezialisiert sein, dass die Inferenz beschleunigt wird, und doch so universell sein, dass sie neue Algorithmen unterstützen. Jahrelang haben FPGAs genau diese Rolle erfüllt: die Kombination aus Leistung und Flexibilität bereitzustellen, die erforderlich ist, um kritische Algorithmen zu beschleunigen, wenn Universalprozessoren nicht ausreichend oder spezialisierte Geräte nicht verfügbar sind. 

FPGAs als Plattformen für maschinelles Lernen

Für maschinelles Lernen setzen GPUs weiterhin Maßstäbe – Maßstäbe, die frühere FPGAs nicht einmal annähernd erreichen konnten. Neuere Geräte wie das FPGA Arria 10 GX von Intel und das FPGA ECP5 von Lattice Semiconductor haben den Abstand zwischen FPGAs und GPUs deutlich verkleinert. Für manche DNN-Architekturen mit kompakten ganzzahligen Datentypen kann diese FPGA-Klasse sogar mehr Leistung/W als eine Standard-GPU liefern.

Hochentwickelte FPGAs erreichen dank ihrer Kombination aus eingebettetem Speicher und Ressourcen für digitale Signalverarbeitung (DSP) hohe Leistungen bei allgemeinen Matrix-Multiplikationen (GEMM). Die Möglichkeit, eingebetteten Speicher nahe an den Berechnungsengines zu platzieren, entschärft den CPU-Speicherengpass, der die Leistung von Algorithmen für maschinelles Lernen auf Universalprozessoren beschränken kann. Eingebettete DSP-Berechnungsengines auf FPGAs wiederum bieten eine größere Anzahl paralleler Multiplikatorressourcen als selbst auf typischen DSP-Geräten verfügbar sind (Bild 1). FPGA-Lieferanten bieten FPGA-Entwicklungsplattformen speziell für maschinelles Lernen an und schöpfen damit die Vorteile dieser Merkmale voll aus.

Der OPENVINO mit FPGA-Unterstützung von Intel beispielsweise erweitert die Möglichkeiten dieser Plattform, um Inferenzmodelle für verschiedene Geräte bereitzustellen, einschließlich GPUs, CPUs und FPGAs. Hier arbeiten Entwickler mit Intels Deep-Learning-Inferenz-Engine-Workflow, der das Deep-Learning-Deployment-Toolkit von Intel und das Intel Computer-Vision-Softwareentwicklungskit (SDK) im OPENVINO-Toolkit von Intel miteinander kombiniert. Entwickler verwenden die Anwendungsprogrammierschnittstelle (API) des SDK, um mithilfe von Intels Run-Model-Optimizer ein Modell zu erstellen, das auf diese verschiedenen Hardware-Plattformen ausgerichtet werden kann. 

Intels Entwicklungskit für ML 

Auf das Intel-Entwicklungskit DK-DEV-10AX115S-A für Arria-10-GX-FPGAs ausgerichtet, ermöglicht das Deep-Learning-Deployment-Toolkit Entwicklern den Import trainierter Modelle aus führenden ML-Frameworks, einschließlich Caffe und TensorFlow (Bild 2). Innerhalb des Toolkits handhaben der Model-Optimizer und die Inference-Engine die Modellkonvertierung beziehungsweise -bereitstellung auf einer Zielplattform wie dem Arria-10-GX-FPGA-Entwicklungskit oder einem benutzerdefinierten Design unter Verwendung einer Arria-10-GX-FPGA-Komponente.

Für die Migration eines bereits trainierten Modells verwenden Entwickler den python-basierten Model Optimizer, um eine in einer xml-Datei enthaltene Zwischendarstellung (Intermediate Representation – IR) zu generieren, die die Netzwerktopologie und eine Bin-Datei bereitstellt. Diese enthält die Modellparameter als Binärwerte. Neben der Erstellung der IR übt der Model-Optimizer eine kritische Funktion bei der Entfernung von Schichten aus, die im Modell für das Training benötigt werden, nicht aber für Inferenz. Zudem führt das Tool Schichten zusammen, die jeweils separate mathematische Operationen, wenn möglich, in einer einzigen kombinierten Schicht zusammenführen.

Das Ergebnis dieser Netzwerkbereinigung und -zusammenführung ist ein kompakteres Modell, das wiederum kürzere Inferenzzeiten und geringere Speicheranforderungen für die Zielplattform mit sich bringt.

Die Inference-Engine von Intel ist eine C++-Bibliothek mit einem Satz C++-Klassen, die in der unterstützten Ziel-Hardware-Plattform gemeinsam verwendet werden, um Inferenz auf der Plattform zu ermöglichen. Für die Inferenzanwendung verwenden Entwickler Klassen wie CNNNetReader, um die CNN-Topologie, die in der xml-Datei enthalten ist (ReadNetwork), und die Modellparameter, die in der Bin-Datei enthalten sind (ReadWeights), zu lesen. Ist das Laden des Modells abgeschlossen, führt ein Aufruf der Klassenmethode Infer() eine blockierende Inferenz aus, während ein Aufruf der Klassenmethode StartAsync() eine Inferenz asynchron ausführt und eine Warte- oder Completion-Routine ausführt, um die Ergebnisse nach Abschluss der Inferenz zu handhaben.

Intel demonstriert den vollständigen Workflow und detaillierte Inference-Engine-API-Aufrufe in einer Reihe von Beispielanwendungen, die in der OPENVINO-Umgebung verfügbar sind. Eine Beispielanwendung für Sicherheitsbarrierenkameras veranschaulicht die Verwendung einer Pipeline aus Inferenzmodellen, um zunächst eine Fahrzeug-Bounding-Box zu identifizieren (Bild 3). Das nächste Modell in der Pipeline untersucht den Inhalt dieser Bounding-Box, um Fahrzeugeigenschaften wie Fahrzeugklasse, Farbe und Ort des Kennzeichens zu ermitteln.

CNNNetwork read() override

{ std::cout << „[ INFO ] Loading network files for Licence Plate Recognition (LPR)“ << std::endl;

CNNNetReader netReader;

/** Read network model **/

netReader.ReadNetwork(FLAGS_m_lpr);

std::cout << „[ INFO ] Batch size is forced to 1 for LPR Network“ << std::endl;

netReader.getNetwork().setBatchSize(1);

/** Extract model name and load it‘s weights **/

std::string binFileName = fileNameNoExt(FLAGS_m_lpr) + „.bin“;

etReader.ReadWeights(binFileName);

/** LPR network should have 2 inputs (and second is just a stub) and one output

**/

// ---------------------------Check inputs

std::cout << „[ INFO ] Checking LPR Network inputs“ << std::endl;

InputsDataMap inputInfo(netReader.getNetwork().getInputsInfo());

if (inputInfo.size() != 2)

{

throw std::logic_error(„LPR should have 2 inputs“);

}

InputInfo::Ptr& inputInfoFirst = inputInfo.begin()->second;

inputInfoFirst->setInputPrecision(Precision::U8);

inputInfoFirst->getInputData()->setLayout(Layout::NCHW);

inputImageName = inputInfo.begin()->first;

auto sequenceInput = (++inputInfo.begin());

inputSeqName = sequenceInput->first;

if (sequenceInput->second->getTensorDesc().getDims()[0] != maxSequenceSizePerPlate)

{

throw std::logic_error(„LPR post-processing assumes certain maximum sequences“);

}

// ---------------------------Check outputs

std::cout << „[ INFO ] Checking LPR Network outputs“ << std::endl;

OutputsDataMap outputInfo(netReader.getNetwork().getOutputsInfo());

if (outputInfo.size() != 1)

{

throw std::logic_error(„LPR should have 1 output“);

}

outputName = outputInfo.begin()->first;

std::cout << „[ INFO ] Loading LPR model to the „<< FLAGS_d_lpr << „ plugin“ «

std::endl;

_enabled = true;

return netReader.getNetwork(); }

Quelle: Intel

Listing 1: Bereitgestellt in der Beispielanwendung für Sicherheitsbarrierenkameras von Intel im OPENVINO-Toolkit zeigt dieses Snippet das Designmuster für den Einsatz der Intel Inference-Engine C++-Bibliotheks-API zum Einlesen eines Modells und seiner Parameter in die Inferenz-Engine.

Das letzte Modell in der Pipeline verwendet diese Fahrzeugeigenschaften, um die Buchstaben des Kennzeichens zu extrahieren. Um das Modell für Inferenz zu nutzen, zeigt der Beispielcode die Verwendung der Inference Model C++-Bibliothek zum Erstellen eines Objekts (LPR), das eine Instanz einer Struktur mit der Bezeichnung LPR-Detection ist. Diese Struktur verwendet Objekte der Inference-Engine-API-Klasse, um zu lesen (CNNNetReader) und Modell-eingaben und -ausgaben zu validieren (Listing 1).

if (LPR.enabled())

{

// licence plate // expanding a bounding box a bit, better for the license plate recognition

result.location.x -= 5;

result.location.y -= 5;

result.location.width += 10;

result.location.height += 10;

auto clippedRect = result.location & cv::Rect(0, 0, width, height);

cv::Mat Plate = frame(clippedRect);

// ----------------------------Run License Plate Recognition

LPR.enqueue(Plate);

t0 = std::chrono::high_resolution_clock::now();

LPR.submitRequest();

LPR.wait();

t1 = std::chrono::high_resolution_clock::now();

LPRNetworktime += std::chrono::duration_cast<ms>(t1 - t0);

LPRInferred++;

// ----------------------------Process outputs

cv::putText(frame,LPR.GetLicencePlateText(),cv::Point2f(result.location.x,result.

location.y+result.location.height+15),cv::FONT_HERSHEY_COMPLEX_SMALL,0.8,cv::Scalar(0, 0, 255));

if (FLAGS_r)

{

std::cout << „License Plate Recognition results:“ << LPR.GetLicencePlateText() << std::endl;

}

}

cv::rectangle(frame, result.location, cv::Scalar(0, 0, 255), 2);

Quelle: Intel

Listing 2: Dieses Snippet aus der Beispielanwendung für Sicherheitsbarrierenkameras von Intel im OPENVINO-Toolkit veranschaulicht das Designmuster für das Laden eines Modells, Durchführen der Inferenz und Bereitstellen der Ergebnisse.

Um Inferenzen durchzuführen, lädt der Code Daten und ruft die Methode SubmitRequest auf, die den Inferenzzyklus initiiert und auf das Ergebnis wartet, um anschließend die auf dem Kennzeichen erkannten Zeichen anzuzeigen (Listing 2).

Integrierte eingebettete Bildverarbeitungsplattform

Während bei Intels OPENVINO-Ansatz Plattform-Retargeting im Vordergrund steht, konzentriert sich Lattice mit der SensAI-Plattform strikt auf FPGA-Inferenz. Zu den Merkmalen der SensAI-Plattform zählt, dass sie FPGA-IP für DNN-Architektur bereitstellt, einschließlich CNNs und einer kompakten Architektur, die als binarisiertes neuronales Netzwerk (BNN) bezeichnet wird. Für Embedded-Vision stellt das SensAI-CNN-IP das Framework für eine vollständige Inferenz-Engine bereit, kombiniert Schnittstellen für ein Steuerungssubsystem, Speicher, Eingang und Ausgang mit Ressourcen, die verschiedene Modellschichttypen implementieren, darunter Faltung, Batch-Norm-Normalisierung, ReLu-Aktivierung, Pooling und andere (Bild 4).

Bei der Implementierung eines CNN-Modells beginnen Entwickler mit der Konfiguration des CNN und nutzen dafür das Konfigurationstool Clarity von Lattice in der Lattice Diamond Designumgebung für ECP5 FPGAs oder Radiant für andere Lattice FPGA-Familien. Hier können Entwickler den Modelltyp (CNN oder BNN), die Anzahl der Faltungs-Engines (max. acht) und die Größe des internen Speichers (bis zu 16 KB) für jede Schicht oder jeden Blob angeben. Nach der Konfiguration des CNN wird die Designumgebung genutzt, um den Kern als FPGA-Bitstrom zu generieren.

Getrennt importieren Entwickler mit Caffe oder TensorFlow entwickelte trainierte Modelle in die SensAI-Plattform. Hier konvertiert der Neural Network Compiler von Lattice die trainierten Caffe- oder TensorFlow-Modelle in einen Dateisatz, der die Modellparameter des neuronalen Netzwerks und die Ausführungsbefehlssequenzen enthält. Die SensAI-Plattform bringt die separaten Ausgänge von der Designumgebung und vom Compiler im FPGA zusammen, um ein letztes Inferenzmodell bereitzustellen (Bild 5).

Vision-Entwicklungskit von Lattice

Für eingebettete Bildverarbeitungsanwendungen bietet das Embedded-Vision-Entwicklungskit (EVDK) LF-EVDK1-EVN von Lattice eine Plattform für das Ausführen von CNN-Modell-Inferenzen. Das EVDK bietet eine vollständige Videoplattform in einem Dreiplatinenstapel der Größe 80 mm × 80 mm, das die Video-Eingangskarte CrossLink von Lattice, eine Prozessorkarte mit einem ECP5-FPGA und eine HDMI-Ausgangskarte beinhaltet. Entwickler können das EVDK als Zielplattform für eine Reihe von CNN-Beispielanwendungen verwenden, die von Lattice erhältlich sind. Zum Beispiel kann das Referenzdesign für das Erkennen von Geschwindigkeits-Verkehrszeichen von Lattice mit dem EVDK verwendet werden, um die Anwendung des SensAI CNN-IP in einer typischen Automobilanwendung zu veranschaulichen (Bild 6).

Die Projektdateien für diese Beispielanwendung beinhalten den kompletten Dateiensatz, angefangen bei den Modellen, die in Caffe-caffemodel- und TensorFlow-pb-Formaten bereitgestellt werden. Dadurch können Entwickler die Details dieser Modelle erforschen. Mit dem TensorFlow-Programm import_pb_to_tensorboard.py beispielsweise können Entwickler das von Lattice bereitgestellte pb-Modell importieren, um die Details des in dieser Beispielanwendung verwendeten CNN zu studieren (Bild 7). In diesem Fall ist das bereitgestellte Modell eine Abfolge von vier Fire-Modulen, wovon ein jedes Folgendes umfasst:

Eine Conv2D-Schicht, die die 3 × 3 Faltung durchführt, um Merkmale aus dem Eingangsstrom zu extrahieren;

eine Aktivierungsschicht, die eine Batch-Norm-Normalisierung durchführt, gefolgt von der Aktivierung einer gleichgerichteten linearen Einheit (Rectified Linear Unit – ReLU);

eine MaxPool-Pooling-Schicht, die den Ausgang der vorherigen Schicht abfragt.

Entwickler können den oben beschriebenen Modell-Prozessablauf durcharbeiten und die SensAI-Plattform zum Generieren der Modelldateien verwenden. Alternativ können Entwickler direkt in die Bereitstellung springen und dazu die bereitgestellten Dateien verwenden. In beiden Fällen werden die Dateien von einer mittels Adapter angeschlossene MicroSD-Karte in das EVDK geladen.

Im Betrieb bietet die Kamera auf dem EVDK einen Videostrom zum ECP5-FPGA, wo das konfigurierte CNN-Beschleuniger-IP Befehlssequenzen zur Durchführung der Inferenz ausführt. Wie bei jeder Inferenz-Engine erzeugt jeder Ausgangskanal ein Ergebnis, das die Wahrscheinlichkeit liefert, dass das mit dem Ausgangskanal verknüpfte Label das korrigierte Label für das Eingangsbild ist. In diesem Fall wurde das Modell mit Bildern von Verkehrszeichen zur Geschwindigkeitsbegrenzung für 25, 30, 35, 40, 45, 50, 55, 60 und 65 Meilen pro Stunde trainiert. Wenn das Modell ein Verkehrszeichen in seinem Eingangsfeld entdeckt, zeigt es folglich die Wahrscheinlichkeit an, dass das erkannte Verkehrszeichen einer Geschwindigkeitsbegrenzung auf 25, 30, 35, 40, 45, 50, 55, 60 oder 65 Meilen pro Stunde entspricht (Bild 8).

Fazit

Beim Einsatz von maschinellem Lernen in eingebetteten Bildverarbeitungsanwendungen waren Entwickler bis jetzt eingeschränkt hinsichtlich der Möglichkeit, die erforderlichen Leistungsniveaus für die Verwendung verfügbarer Hardware-Plattformen zu erzielen. Mit dem Aufkommen von High-Performance-FPGAs können Entwickler jedoch Inferenz-Engines schaffen, die der Leistung von GPUs nahe kommen können. Mit ML-FPGA-Plattformen für eingebettete Bildverarbeitung können sich Entwickler auf ihre spezifischen Anforderungen konzentrieren, Standard-Frameworks für maschinelles Lernen verwenden, um Modelle zu trainieren, und sich darauf verlassen, dass die FPGA-Plattform High-Performance-Inferenz liefert. (fr)

Rich Miron 
arbeitet als Application Engineer bei Digi-Key Electronics und ist seit 2007 in der Gruppe Technical Content tätig. Dort verantwortet er in erster Linie das Schreiben und Bearbeiten von Artikeln, Blogs und Produktschulungsmodulen. Vor seiner Tätigkeit bei Digi-Key testete und qualifizierte er Mess- und Kontrollsysteme für Atom-U-Boote. Rich hat einen Abschluss in Elektrotechnik und Elektronik von der North Dakota State University in Fargo, ND.