[PYTHON] TensorFlow Tutorial-Convolution Neuronales Netz (Übersetzung)

TensorFlow Tutorial (Faltungsneurale Netze) http://www.tensorflow.org/tutorials/deep_cnn/index.html#convolutional-neural-networks Es ist eine Übersetzung von. Wir freuen uns darauf, auf Übersetzungsfehler hinzuweisen.

Hinweis: Dieses Lernprogramm richtet sich an fortgeschrittene TensorFlow-Benutzer und setzt Fachwissen und Erfahrung im Bereich maschinelles Lernen voraus.

Überblick

Die CIFAR-10-Klassifizierung ist ein häufiges Benchmarking-Problem beim maschinellen Lernen. Das Problem besteht darin, RGB-Bilder mit 32 x 32 Pixeln in 10 Kategorien zu kategorisieren: Flugzeuge, Autos, Vögel, Katzen, Hirsche, Hunde, Frösche, Pferde, Schiffe und Lastwagen.

Weitere Informationen finden Sie unter CIFAR-10-Seite und [Technischer Bericht] von Alex Krizhevsky (http://www.cs.toronto.edu/). Siehe% 7Ekriz / learning-features-2009-TR.pdf).

Ziel

Das Ziel dieses Tutorials ist es, ein relativ kleines Faltungs-Neuronales Netzwerk (CNN) für die Bilderkennung aufzubauen. In den Schritten dieses Tutorials:

1. Markieren Sie Standardkonfigurationen für Netzwerkarchitektur, Schulung und Evaluierung.
2. Bietet Vorlagen zum Erstellen größerer und komplexerer Modelle.

Ich habe mich für CIFAR-10 entschieden, weil es komplex genug ist, um einen Großteil der Skalierbarkeit auf ein großes Modell von TensorFlow zu üben. Gleichzeitig ist das Modell klein genug, um schnell zu trainieren. Daher ist es ideal, um neue Ideen auszuprobieren und mit neuen Technologien zu experimentieren.

Tutorial Highlights

Dieses CIFAR-10-Tutorial zeigt einige wichtige Strukturen für das Entwerfen größerer und komplexerer Modelle in TensorFlow:

• Fold, [ReLU-Aktivierung](https://www.tensorflow.org/api_docs/python/nn.html# relu), Maximum Pooling und Local Response Normalization /Nn.html#local_response_normalization), eine zentrale mathematische Komponente
• Visualisierung der Netzwerkaktivität während des Trainings, einschließlich Eingabebildern, Verlust, Aktivierung und Gradientenverteilung (https://www.tensorflow.org/how_tos/summaries_and_tensorboard/index.html)
• Berechnen Sie den gleitenden Durchschnitt der trainierten Parameter und verwenden Sie diese Durchschnittswerte während der Auswertung, um die Vorhersageleistung zu verbessern. Routine zu verwenden
• Implementierung von Learning Rate Schedule, die mit der Zeit systematisch abnimmt
• Prefetch der Eingabedatenwarteschlange (https://www.tensorflow.org/api_docs/python/io_ops.html#shuffle_batch), um das Modell von der Festplattenlatenz und der teuren Image-Vorverarbeitung zu isolieren

Wir bieten auch eine Multi-GPU-Version des Modells an, die Folgendes beschreibt:

• Modelleinstellungen für das Training mit mehreren GPU-Karten gleichzeitig.
• Freigeben und Aktualisieren von Variablen über mehrere GPUs hinweg.

Wir hoffen, dass dieses Tutorial der Ausgangspunkt für die Erstellung eines größeren CNN für Ihre Bildaufgaben in TensorFlow ist.

Modellarchitektur

Das Modell in diesem CIFAR-10-Lernprogramm ist eine mehrschichtige Architektur mit abwechselnden Windungen und Nichtlinearitäten. Auf diese Ebenen folgt eine vollständig verbundene Ebene, die zum Softmax-Klassifikator führt. Das Modell folgt der von Alex Krizhevsky beschriebenen Architektur, mit Ausnahme einiger Unterschiede in den obersten Ebenen.

Dieses Modell wurde auf der GPU trainiert, um innerhalb von Stunden eine maximale Leistung mit einer Genauigkeit von ca. 86% zu erzielen. Weitere Informationen finden Sie unter [unten](# Modellbewertung) und im Code. Es besteht aus 1.068.298 lernbaren Parametern und erfordert ungefähr 19,5 Millionen Multiplikationen und Additionen, um eine einzelne Bildinferenz zu berechnen.

Codestruktur

Der Code für dieses Tutorial finden Sie unter tensorflow / models / image / cifar10 /.

CIFAR-10 Modell

Das CIFAR-10-Netzwerk ist hauptsächlich in [cifar10.py] enthalten (https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/models/image/cifar10/cifar10.py). Das vollständige Trainingsdiagramm enthält ungefähr 765 Operationen. Sie können sehen, dass der Code fast wiederverwendbar gemacht werden kann, indem Sie das Diagramm mit den folgenden Modulen erstellen:

1. Modelleingabe (#Modelleingabe): Eingaben () und verzerrte Eingaben () fügen Operationen zum Lesen und Vorverarbeiten von CIFAR-Bildern zur Auswertung und zum Training hinzu.
2. Modellvorhersage (#Model Prediction): Inference () fügt eine Operation hinzu, um eine Schätzung für das angegebene Bild durchzuführen, dh zu klassifizieren
3. Modelltraining (#Model Training): loss () und train () fügen Operationen hinzu, um Verluste, Gradienten, variable Aktualisierungen und Visualisierungszusammenfassungen zu berechnen.

Modelleingabe

Der Eingabeteil des Modells besteht aus den Funktionen input () und distorted_inputs (), die Bilder aus der CIFAR-10-Binärdatendatei lesen. Da diese Dateien Datensätze mit fester Bytelänge enthalten, verwende ich tf.FixedLengthRecordReader. Weitere Informationen zur Reader-Klasse finden Sie unter Lesen von Daten (https://www.tensorflow.org/how_tos/reading_data/index.html#reading-from-files).

Das Bild wird wie folgt verarbeitet:

• Das Bild wird auf 24 x 24 Pixel zugeschnitten, zentriert für die Bewertung und zufällig für das Training.
• Das Bild ist fast weiß, sodass das Modell nicht vom Dynamikbereich abhängt.

Im Training wenden wir eine Reihe von zufälligen Verzerrungen an, um den Datensatz künstlich zu vergrößern:

• Drehen Sie das Bild nach dem Zufallsprinzip nach links und rechts (https://www.tensorflow.org/api_docs/python/image.html#random_flip_left_right).
• Verzerrt zufällig die [Helligkeit] des Bildes (https://www.tensorflow.org/api_docs/python/image.html#random_brightness)
• Verzerrt den Bildkontrast zufällig (https://www.tensorflow.org/api_docs/python/image.html#tf_image_random_contrast)

Eine Liste der verfügbaren Verzerrungen finden Sie auf der Seite Bilder (https://www.tensorflow.org/api_docs/python/image.html). Hängen Sie image_summary an das Bild an, damit Sie sie in TensorBoard visualisieren können. Wir empfehlen, dass Sie sicherstellen, dass die Eingabedaten korrekt erstellt wurden.

Das Lesen und Verzerren eines Bildes von einer Disc kann einige Zeit dauern. Um zu verhindern, dass dieser Vorgang das Training verlangsamt, wird dies in 16 separaten Threads durchgeführt, die die TensorFlow-Warteschlange kontinuierlich füllen (https://www.tensorflow.org/api_docs/python/io_ops.html#shuffle_batch). Ausführen.

Modellvorhersage

Der Prädiktor des Modells besteht aus der Funktion inference (), die eine Operation zur Berechnung des Logits der Vorhersage hinzufügt. Dieser Teil des Modells ist wie folgt aufgebaut:

Das Diagramm der von TensorBoard generierten Inferenzoperation ist wie folgt.

Übung: Die Ausgabe der Inferenz ist ein nicht normalisiertes Protokoll. Bitte bearbeiten Sie die Netzwerkarchitektur und verwenden Sie tf.softmax (), um eine normalisierte Vorhersage zurückzugeben. ..

Die Funktionen input () und inference () stellen alle Komponenten bereit, die zur Bewertung eines Modells erforderlich sind. Konzentrieren wir uns nun auf Gebäudeoperationen, die das Modell trainieren.

Übung: Die Modellarchitektur von inference () unterscheidet sich geringfügig von dem in cuda-convnet definierten CIFAR-10-Modell. Insbesondere besteht die oberste Ebene von Alex 'Originalmodell aus Teilverknüpfungen, nicht aus Vollverknüpfungen. Versuchen Sie, die Architektur so zu bearbeiten, dass die oberste Ebene eine teilweise Verknüpfung ist.

Modelltraining

Die übliche Methode zum Trainieren eines Netzwerks für die Klassifizierung der N-Klasse ist die Multiterm Logistic Regression (https://en.wikipedia.org/wiki/Multinomial_logistic_regression), auch als Softmax Regression bekannt. Die Softmax-Regression wendet die Nichtlinearität von Softmax auf die Ausgabe des Netzwerks mit normalisierten Vorhersagen und Beschriftungen an 1-Hot Encoding, [Cross Entropy](https://www.tensorflow.org/api_docs/python/nn. html # softmax_cross_entropy_with_logits) wird berechnet. Außerdem wird der normale Gewichtsverlust (https://www.tensorflow.org/api_docs/python/nn.html#l2_loss) auf alle trainierten Variablen zur Regularisierung angewendet. Die Zielfunktion des Modells, die von der Funktion loss () zurückgegeben wird, ist die Summe des Kreuzentropieverlusts und aller dieser Terme des Gewichtsabfalls.

Visualisieren Sie dies in TensorBoard mit scalar_summary:

Standardalgorithmus Steigung ([Training] für andere Methoden (https://www.tensorflow.org/api_docs/python/train). (Siehe HTML)), um das Modell mit einer Lernrate zu trainieren, die exponentiell abnimmt im Laufe der Zeit. Machen.

Die Funktion train () berechnet den Gradienten und aktualisiert die Lernvariablen (weitere Informationen finden Sie unter GradientDescentOptimizer. Fügen Sie die Operationen hinzu, die erforderlich sind, um die Zielfunktion zu minimieren. Diese Funktion gibt eine Operation zurück, die alle Berechnungen ausführt, die zum Trainieren und Aktualisieren des Modells für einen Stapel von Bildern erforderlich sind.

Modellstart und Training

Der Aufbau des Modells ist nun abgeschlossen. Lassen Sie uns das Modell starten und den Trainingsvorgang mit dem Skript cifar10_train.py durchführen.

python cifar10_train.py

Hinweis: Wenn Sie zum ersten Mal ein Thema des CIFAR-10-Lernprogramms ausführen, wird der CIFAR-10-Datensatz automatisch heruntergeladen. Der Datensatz ist ungefähr 160 MB groß. Trinken Sie also Kaffee, wenn Sie ihn zum ersten Mal ausführen.

Sie sollten so etwas sehen:

Filling queue with 20000 CIFAR images before starting to train. This will take a few minutes.
2015-11-04 11:45:45.927302: step 0, loss = 4.68 (2.0 examples/sec; 64.221 sec/batch)
2015-11-04 11:45:49.133065: step 10, loss = 4.66 (533.8 examples/sec; 0.240 sec/batch)
2015-11-04 11:45:51.397710: step 20, loss = 4.64 (597.4 examples/sec; 0.214 sec/batch)
2015-11-04 11:45:54.446850: step 30, loss = 4.62 (391.0 examples/sec; 0.327 sec/batch)
2015-11-04 11:45:57.152676: step 40, loss = 4.61 (430.2 examples/sec; 0.298 sec/batch)
2015-11-04 11:46:00.437717: step 50, loss = 4.59 (406.4 examples/sec; 0.315 sec/batch)
...

Das Skript meldet nicht nur den Gesamtverlust alle 10 Schritte, sondern auch die Geschwindigkeit, mit der der letzte Datenstapel verarbeitet wurde. Einige Kommentare:

• Der erste Datenstapel kann ungewöhnlich langsam sein (z. B. Minuten). Dies liegt daran, dass der Vorverarbeitungsthread die gemischte Warteschlange mit 20.000 verarbeiteten CIFAR-Bildern füllt.

• Der gemeldete Verlust ist der durchschnittliche Verlust der letzten Charge. Beachten Sie, dass dieser Verlust die Summe der Kreuzentropie und aller Gewichtsabfallterme ist.

• Achten Sie auf die Verarbeitungsgeschwindigkeit der Charge. Die oben gezeigten Zahlen wurden mit dem Tesla K40c erhalten. Erwartete Leistungsverschlechterung bei Ausführung unter CPU

Übungen: Während der Experimente kann es oft ärgerlich sein, dass der erste Trainingsschritt zu lange dauert. Reduzieren Sie zuerst die Anzahl der Bilder, die die Warteschlange füllen. Suchen Sie in cifar10.py nach NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN.

cifar10_train.py speichert regelmäßig alle Modellparameter in der Checkpoint-Datei (https://www.tensorflow.org/how_tos/variables/index.html#saving-and-restoring) (https). (: //www.tensorflow.org/api_docs/python/state_ops.html#Saver), bewertet das Modell jedoch nicht. Die Prüfpunktdatei wird von cifar10_eval.py verwendet, um die Vorhersageleistung zu messen (siehe Modellbewertung unten (# Modellbewertung)).

Durch Ausführen der obigen Schritte wird mit dem Training des CIFAR-10-Modells begonnen. Glückwunsch!

Der von cifar10_train.py zurückgegebene Terminaltext bietet nur minimale Einblicke in das Training des Modells. Ich möchte während des Trainings mehr Modellkenntnisse gewinnen:

• Ist der Verlust wirklich reduziert oder ist es nur Lärm?
• Ist das Modell mit dem entsprechenden Bild versehen?
• Sind Farbverläufe, Aktivierungen und Gewichte angemessen?
• Wie hoch ist jetzt die Lernrate?

TensorBoard stammt von cifar10_train.py [SummaryWriter](https://www.tensorflow.org/api_docs/python/train.htmlerSummary Es bietet diese Funktionalität, indem die Daten angezeigt werden, die regelmäßig über exportiert wurden.

Sie können beispielsweise sehen, wie sich die Verteilung von Aktivierung und Spärlichkeit in der Funktion local3 während des Trainings entwickelt:

Es ist besonders interessant, einzelne Verlustfunktionen im Zeitverlauf sowie Gesamtverluste zu verfolgen. Der Verlust zeigt jedoch aufgrund der kleinen Chargengröße, die für das Training verwendet wird, eine erhebliche Menge an Rauschen. In der Praxis ist es sehr nützlich, zusätzlich zu den Rohwerten den gleitenden Durchschnitt zu visualisieren. Sehen Sie, wie das Skript ExponentialMovingAverage (https://www.tensorflow.org/api_docs/python/train.html#ExponentialMovingAverage) für diesen Zweck verwendet.

Modellbewertung

Lassen Sie uns nun bewerten, wie gut das trainierte Modell mit dem bereitgestellten Datensatz funktioniert. Das Modell wird vom Skript cifar10_eval.py ausgewertet. Es erstellt ein Modell mit der Funktion inference () und verwendet alle 10.000 Bilder im CIFAR-10-Bewertungssatz. Es wird eine Genauigkeit von 1 berechnet, dh wie oft die oberen Vorhersagen mit der tatsächlichen Beschriftung des Bildes übereinstimmen.

Ein Evaluierungsskript wird regelmäßig für die neueste von cifar10_train.py erstellte Prüfpunktdatei ausgeführt, um die Verbesserung des Modells während des Trainings zu überwachen.

python cifar10_eval.py

Achten Sie darauf, dass Sie die Evaluierungs- und Schulungsbinärdateien nicht auf derselben GPU ausführen. Andernfalls wird Ihnen der Speicher ausgehen. Führen Sie die Evaluierung gegebenenfalls auf einer anderen GPU aus oder halten Sie die Trainingsbinärdatei auf derselben GPU an.

Sie sollten so etwas sehen:

2015-11-06 08:30:44.391206: precision @ 1 = 0.860
...

Das Skript gibt einfach regelmäßig die Genauigkeit @ 1 zurück, in diesem Fall 86% Genauigkeit. cifar10_eval.py exportiert auch eine Zusammenfassung, die in TensorBoard visualisiert werden kann. Diese Zusammenfassungen bieten zusätzliche Einblicke in das Modell während der Bewertung.

Das Trainingsskript berechnet die gleitende Durchschnittsversion (https://www.tensorflow.org/api_docs/python/train.html#ExponentialMovingAverage) aller trainierten Variablen. Das Bewertungsskript ersetzt die trainierten Modellparameter durch die Version mit gleitendem Durchschnitt. Dieser Austausch verbessert die Leistung des Modells während der Bewertung.

Übung: Sie können die durch die Genauigkeit @ 1 gemessene Vorhersageleistung mithilfe der Modellmittelungsparameter um etwa 3% verbessern. Bearbeiten Sie cifar10_eval.py so, dass der Mittelungsparameter nicht verwendet wird, und überprüfen Sie, ob die Vorhersageleistung beeinträchtigt ist.

Trainingsmodelle mit mehreren GPU-Karten

Aktuelle Workstations können mehrere GPUs für wissenschaftliche und technologische Berechnungen enthalten. TensorFlow kann diese Umgebung nutzen, indem Trainingsvorgänge auf mehreren Karten gleichzeitig durchgeführt werden.

Das Training in parallelen und verteilten Modellen erfordert eine Koordination des Trainingsprozesses. Für später wird eine Kopie des Modells, die von einer Teilmenge der Daten trainiert wird, als Modellreplik bezeichnet.

Wenn Sie einfach die asynchrone Aktualisierung der Modellparameter übernehmen Einzelne Modellrepliken können mit älteren Kopien von Modellparametern trainiert werden, was zu einer weniger als besten Trainingsleistung führt. Umgekehrt ist ein vollständig synchrones Update so langsam wie das langsamste Modellreplikat.

Auf Workstations mit mehreren GPU-Karten hat jede GPU ähnliche Geschwindigkeiten und enthält genügend Speicher, um alle CIFAR-10-Modelle auszuführen. Daher werden wir das Trainingssystem wie folgt gestalten:

• Platzieren Sie einzelne Modellrepliken auf jeder GPU
• Warten Sie, bis die Batch-Datenverarbeitung für alle GPUs abgeschlossen ist, und aktualisieren Sie die Modellparameter synchron

Das Diagramm für dieses Modell ist unten:

Beachten Sie, dass jede GPU einen eindeutigen Batch-Datengradienten sowie eine Schätzung berechnet. Mit dieser Einstellung können Sie große Datenmengen effizient auf GPUs aufteilen.

Diese Einstellung erfordert, dass alle GPUs Modellparameter gemeinsam nutzen. Die Datenübertragung zur und von der GPU ist bekanntlich sehr langsam. Aus diesem Grund haben wir beschlossen, alle Modellparameter in der CPU zu speichern und zu aktualisieren (siehe grünes Kästchen). Nachdem ein neuer Datenstapel von allen GPUs verarbeitet wurde, wird ein neuer Modellparametersatz an die GPUs übertragen.

Die GPU ist im Betrieb synchronisiert. Alle Gradienten werden von der GPU akkumuliert und gemittelt (siehe grünes Kästchen). Modellparameter werden mit dem durchschnittlichen Gradienten aller Modellrepliken aktualisiert.

Platzierung von Variablen und Operationen auf dem Gerät

Das Platzieren von Operationen und Variablen auf dem Gerät erfordert eine spezielle Abstraktion.

Die erste Abstraktion, die wir benötigen, ist eine Funktion zum Ableiten und Berechnen des Gradienten einer einzelnen Modellreplik. Im Code wird diese Abstraktion "Turm" genannt. Sie müssen zwei Attribute für jeden Turm festlegen.

• Eindeutiger Name für alle Operationen im Turm. tf.name_scope () stellt diesen eindeutigen Namen durch Hinzufügen eines Bereichs bereit. Zum Beispiel wird Turm_0 jeder Operation im ersten Turm vorangestellt, zum Beispiel Turm_0 / conv1 / Conv2D

• Das bevorzugte Hardwaregerät führt die Vorgänge im Tower aus. tf.device () macht dies explizit. Beispielsweise sollten alle Vorgänge, die sich im Gerätebereich ('/ gpu: 0') im ersten Tower befinden, auf der ersten GPU ausgeführt werden.

Alle Variablen sind an die CPU gebunden und können von mehreren GPU-Versionen über [tf.get_variable ()] gemeinsam genutzt werden (https://www.tensorflow.org/api_docs/python/state_ops.html#get_variable). Zugreifen. Weitere Informationen finden Sie unter Gemeinsame Variablen (https://www.tensorflow.org/how_tos/variable_scope/index.html).

Modellstart und Training auf mehreren GPU-Karten

Wenn Sie mehrere GPU-Karten haben und diese auf Ihrem Computer installiert sind, können Sie sie mit dem Skript cifar10_multi_gpu_train.py verwenden, um Ihr Modell schneller zu trainieren. Diese Version des Trainingsskripts parallelisiert das Modell über mehrere GPU-Karten hinweg.

python cifar10_multi_gpu_train.py --num_gpus=2

Die Ausgabe des Trainingsskripts sollte folgendermaßen aussehen:

Filling queue with 20000 CIFAR images before starting to train. This will take a few minutes.
2015-11-04 11:45:45.927302: step 0, loss = 4.68 (2.0 examples/sec; 64.221 sec/batch)
2015-11-04 11:45:49.133065: step 10, loss = 4.66 (533.8 examples/sec; 0.240 sec/batch)
2015-11-04 11:45:51.397710: step 20, loss = 4.64 (597.4 examples/sec; 0.214 sec/batch)
2015-11-04 11:45:54.446850: step 30, loss = 4.62 (391.0 examples/sec; 0.327 sec/batch)
2015-11-04 11:45:57.152676: step 40, loss = 4.61 (430.2 examples/sec; 0.298 sec/batch)
2015-11-04 11:46:00.437717: step 50, loss = 4.59 (406.4 examples/sec; 0.315 sec/batch)
...

Beachten Sie, dass die Anzahl der GPU-Karten standardmäßig 1 beträgt. Wenn auf Ihrem Computer nur eine GPU verfügbar ist, werden alle Berechnungen auf dieser einen GPU platziert, auch wenn Sie mehr anfordern.

Übung: Standardmäßig wird cifar10_train.py mit einer Stapelgröße von 128 ausgeführt. Führen Sie cifar10_multi_gpu_train.py auf zwei GPUs mit einer Stapelgröße von 64 aus und vergleichen Sie die Trainingsgeschwindigkeiten.

Nächster Schritt

Glückwunsch! Sie haben das CIFAR-10-Tutorial abgeschlossen.

Wenn Sie daran interessiert sind, ein eigenes Bildklassifizierungssystem zu entwickeln und zu trainieren, empfehlen wir Ihnen, dieses Lernprogramm aufzuteilen und die Komponenten auszutauschen, um dieses Bildklassifizierungsproblem zu beheben.

Übung: Street View House Numbers (SVHN) Laden Sie den Datensatz herunter. Fork das CIFAR-10-Tutorial und tausche die Eingabedaten gegen SVHN aus. Versuchen Sie, Ihre Netzwerkarchitektur zu ändern, um die Vorhersageleistung zu verbessern.