Oktober 2018
Band 33, Nummer 10
Dieser Artikel wurde maschinell übersetzt.
GPU-Programmierung – mit dem Eigenfaces-Algorithmus auf dem GPU Gesichtserkennung
Durch Kishore Mulchandani
Maschinelles sehen ist, einen Bereich der Informatik, das umfasst die Identifikation oder Bezeichnung von Regionen in einem Bild. Images sind große 2-D-Arrays von Pixeln, die bei parallel verarbeitet werden können. GPUs eignen sich für die Beschleunigung von Algorithmen, bedeuten, die große Mengen an Datenparallelismus, eine Art von Parallelität in der verschiedene Teile eines Datasets nach auf mehreren Prozessoren gleichzeitig verarbeitet werden können. Aus diesem Grund sollte es möglich, GPUs auf die Aufgabe der Implementierung von effizienten Computer Vision Algorithmen anzuwenden. In diesem Artikel verwende ich die GPU zum Implementieren der gesichtserkennung, eines gängigen Problems in maschinelles sehen.
Gesichtserkennung, ermittelt wie der Name schon sagt, Sie Bereiche in ein Foto oder ein Bild ab, die ein Gesicht entsprechen. Dies ist eine wichtige Komponente für Anwendungen, die beim Anwenden eines Filters zu behandeln oder bearbeiten Sie ein Gesicht in einem Bild. Automatische Unschärfe, maskiert, Hervorhebung und Verbessern der Beispiele aus, die erfordern, zu wissen, welche Pixel geändert werden sollte, um den Vorgang abzuschließen.
Es gibt mehrere Algorithmen derzeit verwendet, um Gesichter erkannt, aber in diesem Artikel werde ich die Eigenfaces-Methode, eines der frühesten veröffentlichten Gesicht Methoden nutzen können. Es ist auch rechenintensive. Mein Ziel ist die Verwendung des GPUs, um einen rechnerisch anspruchsvollen Algorithmus zu beschleunigen, und stellen eine allgemeine Einführung in die Programmierung auf der GPU.
Im Artikel wird eine gewisse Vertrautheit mit C-ähnlichen Sprachen und die allgemeinen Konzepte der linearen Algebra und-Verarbeitung vorausgesetzt.
Eigenfaces
Von lineare Algebra wissen Sie, wenn Sie eine Auflistung von n-dimensionalen Punkten verfügen, einige Hauptkomponenten oder eigenvektoren, für diese Auflistung zu finden. Diese eigenvektoren bilden auch die Grundlage des Speicherplatzes für diese Punkte. Die Eigenvector von grundlegender Bedeutung ist die mit der größten Eigenvalue. Alle neuen Punkt, die zu dieser Auflistung gehört, sollte auch einen höheren Wert für die Projektion für die wichtigsten Eigenvector besitzen.
Die Eigenfaces-Methode wird fortgesetzt, indem eine Auflistung von Gesichtern in n-dimensionalen Punkte konvertiert werden. Dies erfolgt durch Konvertieren jedes zweidimensionalen Bild in einen eindimensionalen Vektor. Die gesamte Auflistung wird in einer Matrix große gepackt, in dem jede Spalte der 1-D-Vektor ist. Eigenvektoren und eigenwerte dar, sind für das quadratische Matrix durch Multiplikation der Matrix mit der ihre Transposition gebildet gefunden. Die Ermittlung von eigenvektoren für eine Auflistung von Punkten wird auch als hauptkomponentenanalyse bezeichnet, und die eigenvektoren werden als Hauptkomponenten bezeichnet.
Der Ausgangspunkt für die Algorithmen zur Erkennung Gesicht ist eine gute Datenbank von Gesichtern. Es gibt einige im Internet verfügbar, aber für diesen Artikel mir verwenden, der die öffentlich verfügbaren "mit der Bezeichnung Gesichter in the Wild" Auflistung (Vis-www.cs.umass.edu/lfw). Eine Ableitung von der Auflistung in Graustufen konvertiert steht als Download im conradsanderson.id.au/lfwcrop und wird auch im Download zu diesem Artikel bereitgestellt. Diese Sammlung besteht aus 13,233 64 × 64 Graustufenbildern von Gesichtern. Abbildung 1 zeigt eine Teilmenge der Images. Beachten Sie, dass alle Images zugeschnitten wurde haben, um nur das Gesicht einzuschließen.
.png "Die ersten 100 Bilder in den Gesichtern liefert bezeichneten im Wild-Dataset")
Abbildung 1: die ersten 100 Bilder in den Gesichtern liefert bezeichneten im Wild-Dataset
Sehen Sie eine gepackte Matrix, in denen Sie jede Spalte in der Matrix ein 1-D-Gesicht aus dem Dataset ist, in abbildung2. Beachten Sie, dass der hohen Intensität entlang der Zeilen für dieses Bild überein.
.png "Skalierte Darstellung der großen Matrix mit 4.096 Zeilen und 13,233 Spalten")
Abbildung 2 skaliert Darstellung der großen Matrix mit 4.096 Zeilen und 13,233 Spalten
Nachdem die eigenvektoren und eigenwerte dar gefunden wurden, sieht die wichtigsten Eigenvector beim als eine 2D-Image Clientszenarios das unscharf Gesicht in Abbildung 3.
.png "Erste Eigenface der großen Matrix")
Abbildung 3 erste Eigenface der großen Matrix
Sobald die erste Eigenface berechnet wurde, besteht der nächste Schritt, um den Test-Images für Regionen zu suchen, in denen Projektion der Eigenface einen hohen Wert erreicht. Diesem großen Wert gibt an, dass der Test-Image-Region und die Eigenface nah beieinander in der n-dimensionalen Raum von Gesichtern sind. Die Suche Regionen werden 64 × 64 Pixelbereiche, die bei jedem Pixel des Bilds Test ab. Jede Suche ist unabhängig von der Suche mit anderen ab Pixel, was bedeutet, dass ein hohes Maß an Datenparallelismus vorhanden ist.
Wie bereits erwähnt, excel-GPUs auf parallele Berechnungen zu beschleunigen. Aber das bedeutet nicht, dass jeder Algorithmus auf dem GPU implementiert werden soll. Die Systemarchitektur hat immer noch eine relativ langsame Verbindung zwischen den Systemspeicher und GPU-Speicher. Die Daten verarbeitet werden sollen, müssen einen Bus PCI Express durchlaufen auch bei der PCI-e-Gen 4 pro Bereich nur bis zu 32GT/s, relativ sehr viel Übertragung langsamer als die zwischen der CPU und Arbeitsspeicher übertragen werden können. Dies bedeutet, dass Anwendungen, die keine hohen Latenzen tolerieren wird nicht effektiv auf der GPU ausgeführt werden. Die Größe des Datasets muss groß genug, um den Aufwand beim Kopieren der das in den Arbeitsspeicher des Systems auf den GPU-Arbeitsspeicher zu rechtfertigen und zurück zu sein. Wenn eine Anwendung eine ausgesprochen große Workload im Hinblick auf die Größe der Daten hat, die Vorgänge ausgeführt werden ähnlich sind und alle zum Ausführen der Aufgabe erforderlichen Daten in der GPU-Arbeitsspeicher passt, ist die GPU ein Prozessor ideal, für die Anwendung. Wie ich, im Fall von gesichtserkennung zeigen werde, eignet sich die GPU für einen Teil der Verarbeitung.
Erkennungsalgorithmus Gesicht ist in zwei Phasen. Die erste Phase besteht aus dem Erstellen einer Matrix Eigenface für eine Sammlung von Gesichtern. Da diese Sammlung in der Regel nicht ändert, muss die Berechnung für die Berechnung der Eigenface Matrix nur einmal pro Sammlung ausgeführt werden. Die zweite Phase ist die Projektionsphase, in der eine Test-Region, auf die erste Eigenface projiziert wird, um festzustellen, wie groß die Projektion ist. In dieser Phase ist sehr häufig durchgeführt. In einem auftreten in dieser Phase der Kamera-Anwendung z. B. auf 30 Frames pro Sekunde, die große Datenmengen erzeugen. Die Auflösung der Bilder kann auch sehr groß sein, als auch die kostengünstigste Webcams heutzutage HD-Lösungen unterstützen. Darüber hinaus Gesicht Erkennung Programme häufig mit anderen Grafikoperationen, z. B. Weichzeichnen oder hervorheben, ausgeführt wird, und die Ergebnisse der gesichtserkennung werden von einem anderen Teil des Programms auf der GPU verarbeitet.
Phase 1 ist also kein guter Kandidat für die GPU-Implementierung, die anhand der mit niedriger Häufigkeit, mit denen sie ausgeführt werden, während der Phase zwei eine ausgezeichnete Übereinstimmung für eine GPU-Implementierung ist, wie sie alle folgenden Kriterien erfüllt, muss.
In den folgenden Abschnitten zeige ich Ihnen wie Sie der Phase werden zwei der gesichtserkennung, zunächst möchte jedoch erweitern, auf wie die GPU-Programmierung, die auf der CPU unterscheidet.
Die GPU-Programmierung
Das Paradigma der Programmierung der GPU unterscheidet sich deutlich von der CPU. Für das Betriebssystem eine GPU angezeigt wird, als Gerät aus, und der installierten Treiber die Ausführung der Arbeit auf diesem Gerät zu verwalten. Das Betriebssystem und die GPU-Treiber arbeiten zusammen, um Unterstützung bei der Aufgaben. Auf der untersten Ebene wird eine Sequenz von Befehlen an die GPU-Gerät über seine Warteschlangen Befehl gesendet. Die Befehle können das Festlegen des Status, Kopieren von Daten zwischen CPU, Arbeitsspeicher und GPU-Speicher und Ausführen von Code umfassen. GPUs haben ihre eigenen Sprache Anweisung, die sich maßgeblich von der CPU-Sprache. Glücklicherweise ist dies nicht etwas, das Sie wissen, es sei denn, Sie GPU-Compiler entwickeln müssen. Die meisten Programmierer verwenden eine oder mehrere APIs, die GPU-Hersteller in ihre Treiber, z. B. Direct3D, OpenCL und OpenGL zu implementieren. Diese APIs verbergen die Low-Level Komplexität und gleichzeitig Kompatibilität und Portabilität auf verschiedenen Anbietern und -Familien von Architekturen.
In diesem Artikel habe ich OpenCL, ein Standard verwenden, die von allen wichtigen CPU- und GPU-Anbieter unterstützt wird. OpenCL wurde um seit 2009 wurden mehrere Versionen, die die neuesten wird Version 2.2, und es ständig weiterentwickelt (khronos.org/opencl). Zu beachtende OpenCL Fakt sehr wichtiger ist, dass es nicht nur die GPU, sondern auch die CPU als Ziel verwenden kann. Dies ist ein sehr großer Vorteil für OpenCL, da es bedeutet, dass Sie können die Compute-Ressourcen auf einem System verwenden. Aus diesem Grund wird eine parallele Programmier-API für heterogene Systeme OpenCL genannt. Ein OpenCL Hostprogramm kann die Verfügbarkeit und die Funktionen des die computinggeräte untersuchen, bevor Sie sich entscheiden, welche verwenden.
Glücklicherweise sind Programmiermodell und Abstraktionen zwischen den verschiedenen APIs sehr ähnlich. Dies bedeutet, dass Sie die Konzepte, die Erkenntnisse in OpenCL an andere APIs ohne schwierigkeiten zuordnen können. Lassen Sie uns nun erfahren Sie über eine OpenCL-Implementierung für die gesichtserkennung.
Einrichten der Umgebung
Zum Entwickeln von mit OpenCL, neben der Common Language runtimeunterstützung im Treiber, benötigen Sie das SDK vom jeweiligen Hersteller. Finden Sie in der Dokumentation im digitalen Download zu diesem Artikel.
Da OpenCL ein offener Standard ist, kann beliebige Anbieter ihre eigene Version der Runtime für ihre Hardware optimiert bereitstellen.
Das Programmiermodelle OpenCL-Vokabular besteht aus der Plattformen, Geräte und Befehl Warteschlangen. Eine Plattform ist gleichbedeutend mit einer Implementierung, die auf einem System zur Verfügung. Ein Gerät bezieht sich auf die Hardware kann unabhängig von anderen Geräten geplant. Jeder Computer hat mindestens eine CPU-Gerät. Die meisten Arbeitsstationen oder Computer Gaming-Klasse hat eine einzelne GPU, die als ein zusätzliches Gerät aufgeführt werden. High-End-engineering-Arbeitsstationen verfügen häufig über mehrere GPUs, mit einem angefügt, um anzuzeigen, während andere für die Compute-Verwendung reserviert sind. Jedes Gerät kann mehrere Befehl Warteschlangen aufweisen, in denen ein Programm Befehle eingefügt wird.
Jede OpenCL-Programm, das auf einem Host ausgeführt beginnt, festzustellen, das die Funktionen des Systems auf dem er ausgeführt wird. Das Hostprogramm versucht, die auf dem System verfügbaren Plattformen zu identifizieren, und klicken Sie dann die Geräte aufgelistet. Das Programm kann insbesondere ein Gerät anfordern, und geben z. B. einen Gerätetyp CPU oder GPU-Gerät. Sobald ein Gerät ausgewählt wurde, erstellen Sie einen Kontext und einer Befehlswarteschlange für jedes Gerät, die Sie verwenden möchten. Hier sind einige Aufrufe, die zum Ausführen der oben genannten Vorgänge (aus Gründen der Übersichtlichkeit, die ich für die Aufrufe erforderlichen Parameter ausgeschlossen haben):
clGetPlatformIDs(...); // Gets the ids of the platforms available
clGetDeviceIDs(...); // Gets the devices with certain capabilities
clCreateContext(...); // Creates a context on the device
clCreateCommandQueueWithProperties(...); // Creates a command queue with
// certain properties
Nachdem Sie die Befehlswarteschlange eingerichtet haben, erstellt das Hostprogramm Puffer, auf dem Gerät, das schreibgeschützten, nur Schreibzugriff oder Lese-/ Schreibzugriff werden können. Die Puffer müssen initialisiert werden, mit Daten aus den Systemspeicher, bevor sie keine sinnvollen verwendet werden können:
clCreateBuffer(...); // Creates a read only buffer on the device
clEnqueueWriteImage(...); // Queues a buffer copy from the system to
// device memory
Die Daten werden meist große Puffer oder Arrays mit ganzzahligen und Gleitkommawerten und werden in der Regel asynchron kopiert. Die Puffer, in denen die rechenleistung erfolgt gespeichert werden, werden auf ähnliche Weise auf dem Gerät erstellt. OpenCL verfügt über spezielle Datentypen namens Bilder. Viele rechenintensiven Aufgaben, stammen in der Regel in Form von Bildern oder 3-d-Datasets, in denen nützlich sein, diese speziellen Datentypen. Diese Typen unterstützen verschiedene Vorgänge wie das nächste Beispiel sampling oder Ermitteln des Durchschnitts.
Die Programme oder den Kernel müssen, wie sie in der Terminologie von OpenCL bezeichnet sind kompiliert und verknüpft und in der Warteschlange, in der Befehlswarteschlange. Ich werde später zu diesem Aspekt Details, wie die CPU-Programmierer fragen sich möglicherweise, warum der Kernel zur Laufzeit kompiliert werden:
clCreateProgramWithSource(...); // Create a program from kernel source
clBuildProgram(...); // The program is compiled; errors from compilation
// are reported
clCreateKernel(...); // The kernel is created from the program
Sobald der Kernel erstellt wurde, werden die Argumente für den Kernel eingerichtet, und der Kernel wird dann in die Warteschlange für die Ausführung in der Befehlswarteschlange:
clSetKernelArg(...); // Set the value of a particular argument
clEnqueueNDRangeKernel(...); // Queue the kernel
Es gibt zwei Kernels im begleitenden Quellcode, eine, die die Projektion eines Bereichs auf die Eigenface ausführt und die andere lokale sucht nach Ihren Spitzenwert erreicht, aus den Ergebnissen der Projektion. Des projektionsvorgangs ist im Wesentlichen eine Skalarprodukt Vektor.
Große Werte für das Skalarprodukt zwangsläufig zu mehr ähnlichkeiten zwischen der Region, in der Abbildung und der Eigenface. Diese große Werte oder Spitzen mit dem zweiten Kernel befinden. Da die Ergebnisse der erste Kernel verfügbar sein müssen, bevor der zweite Kernel, die sie verwenden kann, OpenCL-Ereignisse dienen zum Synchronisieren. Das Hostprogramm kann auf ein oder mehrere Ereignisse, die mit dem folgenden API-Aufruf zu warten:
clWaitForEvents(...);
Nachdem die beiden Kernels auf dem Gerät ausgeführt wurden, werden die Ergebnisse des zweiten Kernels in einem Puffer Gerät, die dann an den Hostspeicher kopiert wird, in dem er weiter verwendet werden kann.
Jetzt sehen wir uns eine der Kernel, die in gestartet wird Abbildung 4. Dieser Kernel wird für jedes Pixel in der Abbildung Test bezeichnet. Es sucht zuerst die Summe aus der 4.096-dimensionaler Vektor (64 x 64) des Bereichs dieses Pixel ab, und klicken Sie dann subtrahiert einen Faktor von der Summe aus jedes Pixel des Bereichs. Klicken Sie dann berechnet das Skalarprodukt aus dieser Region mit der Eigenface, die in den Kernel als Argument übergeben wird.
Abbildung 4: der OpenCL-Kernel zum Erstellen einer Projektion Eigenface in einer Region in der Test-Abbildung
__kernel void eigenFaceSearch(
__read_only image2d_t testImage, // Input test image
__write_only image2d_t projectionImage, // Output projection image
int rows, // Number of rows in the test image
int cols, // Number of columns in the test image
__constant float* eigenFace, // The first eigenface buffer
sampler_t sampler // Sampler for reading the image data
)
{
int myCol = get_global_id(0); // Column index of test image pixel
int myRow = get_global_id(1); // Row index of test image pixel
float4 dotp = {0.0f, 0.0f, 0.0f, 0.0f}; // Resulting dot project variable
float4 pixel = {0.0f, 0.0f, 0.0f, 0.0f};// Variable for reading the pixel
float sum = 0.f; // Sum of the pixels in the test region
float meanVal=0.f;
float patch[4096]; // Local buffer to hold the mean
// subtracted region
int2 myCoords; // Local variable for holding current
// pixels coords
myCoords.x = myCol;
myCoords.y = myRow;
if (!(( myCol > cols-64) || (myRow > rows - 64))) { // Bounds check
for (int i = 0; i < 64; i++) { // Loop over every pixel in test region
int2 coords;
coords.y = myRow + i;
for (int j = 0; j < 64; j++) {
coords.x = myCol + j;
// Read the pixel at coords, from the test image using the sampler
pixel = read_imagef(testImage, sampler, coords);
patch[i*64+j] = pixel.x; // Take the first component as it is a single
// float buffer
sum += patch[i*64+j]; // Accumulate the sum
}
}
meanVal = sum / 256.; // An intensity factor proportional to sum.
for (int i= 0; i < 4096; i++){ // Remove from each pixel
patch[i] -= meanVal; // Per component subtract of intensity factor
}
// Perform the dot product
for (int i= 0; i < 4096; i++){
dotp.x += patch[i] * eigenFace[i]; // Do the component-wise dot product
}
// Write back the dot product into the projection Image
write_imagef(projectionImage, myCoords, dotp);
}
}
Kompilieren den Kernel OpenCL
Wie bereits erwähnt, wird der Compiler OpenCL zur Laufzeit aufgerufen, durch das Hostprogramm. Der Compiler wird als eine Zeichenfolge mit der gesamten Quelle der Kernel bereitgestellt. In vielen Fällen Kernels sind eher kleine Codeelemente, die sehr schnell zu kompilieren, und es sei denn, Ihre Anwendung anfällig für jede zusätzliche Millisekunde schon alles ist, um die Ergebnisse zu erhalten, Sie wahrscheinlich erst gar nicht darüber. Aber für komplexe Anwendungen mit Hunderten von Kernel, die Verzögerung bemerkt werden kann. Glücklicherweise Zwischensprache (IL) Optionen vorhanden sind, können die gesamte Kompilierungszeiten denen reduzieren. (IL hilft auch beim Schutz von geistigen Eigentums, das als eingebettete Zeichenfolgen von Kernelcode möglicherweise vertrauliche Informationen verraten.) Der Vorteil von der Common Language runtimekompilierung des Kernels ist, dass die Anwendung stabil gegenüber Änderungen in der Hardware vereinfacht. Es ist üblich für PC-Benutzer, ihre GPUs während der Lebensdauer ihrer Computer zu aktualisieren. Eine neue GPU mit einer neuen Architektur handelt es sich möglicherweise um eine völlig neue Anweisung festgelegt, die verlassen vorkompilierte Binärdateien aus einer älteren GPU kann nicht verwendet.
Diese überlappender Zusammenführung
Das Bild Eigenface berechnet und als eine binäre Datei, die mit einfacher Genauigkeit Float-Daten in zeilengerichteter Reihenfolge angegeben. Der Test-Images werden auch in Gleitkomma Graustufen Images konvertiert. Der Test-Images weisen folgendes Format:
Height: 4 byte unsigned integer
// The number of rows in the image
Width: 4 byte unsigned integer
// The number of columns in the image
Intensity Buffer: Height * width single precision floating point buffer
// Data buffer
Mit solchen ein einfaches Format sollte er sein einfach zu Test-Images zu generieren, die von meiner Anwendung genutzt werden können. Die Ergebnisse der Berechnung werden auch als Puffer von Gleitkommadaten, gespeichert. Darüber hinaus wird eine Textdatei mit den Koordinaten der oberen linken Ecke des alle Rechtecke mit Gesichter generiert. Diese Daten können in jedem Programm importiert werden. Ich speichere die Daten für die Nutzung in MATLAB (bit.ly/2isajNJ).
Das Programm kann einfach geändert werden, um auf die CPU statt GPU ausgeführt werden.
Ergebnisse der Ausführung
Ich haben die Anwendung auf mehrere Test-Images ausgeführt. Da der Code derzeit nach sucht nur 64 × 64 Regionen, wenn der Test-Images größere haben oder kleinere auskennen, ich wäre nicht erwarten, dass gute finden entspricht. Allerdings, wenn der Test-Images ungefähr die gleiche Größe wie die Eigenface verfügen, sofern die Flächen gedreht werden, sollten sie auch tun. Ergebnisse von meinen Testlauf auf ein Bild, berühmten Abbildung 5. Gesichter wurden mithilfe der Eigenfaces-Methode mit nicht normalisierten Projektion des Bereichs auf den ersten Eigenface identifiziert.
.png "Eine Fotografieren erstellt auf der fünften Solvay-Konferenz in 1927 gespeichert")
Abbildung 5: Foto entfernt auf der fünften Solvay-Konferenz in 1927 gespeichert
Ich habe einige fälschlich positiver und "false". Mehrere Flächen verpasst wurden, und viele nicht-Face-Bereiche hervorgehoben wurden. Einiges davon ist das Ergebnis der lokalen Maxima Search-Methode, mit denen die hohe Werte (Spitzenwerte) erkennen in der Projektion-Abbildung. Ich einfach wird die Höhe von 97 x 97-Pixel, um festzustellen, ob ich einen höheren Wert wäre etwa durchsucht. In der Folge wurden mehrere Bereiche hervorgehoben wurden, bei der es mussten keine Gesichter aber dennoch einen höheren Wert als der lokalen Umgebung. Diese Methode kann bei verbessert werden, um falsche positivmeldungen zu verringern.
Bedenken Sie, von denen die Qualität der Images im Beispiel ist die Qualität der Ergebnisse abhängig, der z. B. der bildauflösung von Lichtverhältnissen und die Variabilität in die Intensitäten enthält.
OpenCL auf GPU Vs. CPU
Es gibt mehrere parallelverarbeitung Technologien auf dem Front CPU von SIMD-Vektorisierung, um explizite multithreading, um Compiler-Pragmas in der OpenMP-Style-Parallelisierung von Schleifen. Um wirklich vergleichen wäre was schneller ist, oder verfügt über einen höheren Durchsatz sehr schwierig sein, wenn jede mögliche Kombination aus Technologien mit umfassend optimierte Implementierungen getestet wurde. Angegebene wie einfach es ist von einem Gerätetyp in eine andere in Code zu wechseln, ich habe mich entschieden, es einmal auszuprobieren.
Ich habe das Programm ausgeführt wird, auf beide Gerätetypen, die CPU und GPU, und auf zwei verschiedene "Platforms." Ich führte dies auf System wurde ein Gaming-Laptop mit einer Intel Core i7 - 8750H CPU @2.20 GHz, 16 GB RAM mit einer NVIDIA GeForce GTX 1060 GPU. Ich konnte ein CPU-Gerät auf alle drei Plattformen oder einen GPU-Gerät-Typ auf eine von NVIDIA gewählt haben. Beachten Sie, dass ein GPU-Hersteller kann eine CPU-Implementierung, zusammen mit die GPU-Implementierung bereitstellen, die in diesem Fall ist es weniger wahrscheinlich optimiert werden.
Wie erwartet ausgeführt GPU besser, mit der CPU-Version 12 bis 21 Mal länger dauert, siehe Abbildung 6. Während der profilerstellung keine e/a enthalten jedoch die Zeit für die Puffer aus dem System in den Speicher des Geräts zu kopieren. Alle Zeitangaben sind in Millisekunden.
.png "Vergleich der GPU und CPU-Eigenface Suchimplementierung Zeiten OpenCL")
Abbildung 6: Vergleich der GPU und CPU-Eigenface Suchimplementierung Zeiten OpenCL
Der Kernel geschrieben wurden, mit der Absicht, erfahren, und nehmen Sie diese Vergleiche mit einer Auflösung der Salt-Wert, nicht, um die bestmögliche Leistung, zu erhalten. Tatsächlich ist die Optimierung der Leistung von Kernels, ein komplexer Prozess, und ein wichtiger Schritt vor der Bereitstellung eines Programms. Pipelining Pufferkopien, Reduzierung der Anzahl von Registern in der Kernel aus, und halten Speicherzugriffe kohärent sind einige Techniken zum Optimieren der Kernel beschäftigt.
Die Tatsache, dass das gleiche OpenCL Hostprogramm können gleichzeitig Arbeit in eine Warteschlange für all die verschiedenen Geräte, die auf einem System verfügbaren bedeutet, dass Sie durch den Einsatz von allen Geräten Durchsatz noch weiter erhöhen können. Wenn Sie die gesichtserkennung auf video-Sicherheit die Bearbeitung ausführen, z. B. konnte Sie jeder Frame Teilen oder subframe zwischen verschiedenen Geräten Warteschlangen proportional zu ihren Durchsatz. Der Systemarbeitsspeicher und Systembusse weiterhin freigegeben werden könnte werden Engpässe, also leider und Sie nicht die Leistung durch das Hinzufügen von weiteren Geräten unbegrenzt skalieren.
Eigen nichts
Obwohl in diesem Artikel konzentrieren sich auf die Gesichter von Personen erkennen, ist "nothing", die verhindert, dass dieser Ansatz zum Erkennen von anderen Entitäten bzw. Objekte angewendet wird. Der Trick besteht darin, eine brauchbare Anzahl von Test-Images zu sammeln, führen einige vorverarbeitung zur stellen die gleiche Größe, registrieren Sie den Speicherort des einige wichtige Features und berechnen Sie dann auf die eigenvektoren. Nachdem die eigenvektoren erstellt wurden, bleibt der Search-Code unverändert. Also, wenn Sie Code zum Erkennen von Hand für eine Anwendung könnte Polnisch visualisieren entwickeln, könnten eine Datenbank mit der Hand nehmen und generieren die "Eigenhands" und suchen Sie in einem Bild für die Hände gelangen, in denen möglicherweise. Mit augmented Reality-Anwendungen steigt werden diese Arten von Anwendungen wahrscheinlich angezeigt werden.
Zusammenfassung
Für einen Programmierer, die GPU-Entwicklung, zum ersten Mal systemimplementierung es kann eine steile Lernkurve, aber die Vorteile können sich diese Investition werden. GPUs haben viel rechenleistung, die in Programmiersprachen wie OpenCL genutzt werden können. Dieser Artikel dient als Einführung in die GPU-Programmierung, während das beliebte reale Problem der Suche nach Gesichtern in einem Bild, das mit dem Eigenfaces Ansatz veranschaulicht. Dieser Ansatz kann mit anderen Formen und Objekte erweitert werden.
Kishore Mulchandani3D-Grafiken Anwendungen entwickelt und leistungsverbesserungen in parallel auf CPUs und GPUs ausgeführte Code ist. Leistungsstarke computing, Benchmark-Entwicklung für Grafiken, 3D Form Rekonstruktion von 2-D-Image-Daten, die mit der maschinelles sehen und Edutainment virtual Reality-Anwendungen sind einige seine neuesten Interessen und Aufgaben. Er ist unter Kishore@vanishinglines.com.
Unser Dank gilt den folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: James McCaffrey, Ravi Shankar Kolli