Beispiel für einen Deep Learning-Workflow mit einer FRA1-1 vGPU VM CODE-DE
Hier werden die Deep Learning-Tools TensorFlow und Keras zur Durchführung einer benutzerdefinierten Bildklassifizierung auf vGPU in der Cloud {{ waw3_1 }} verwendet.
Die Verwendung von (v)GPU beschleunigt die mit Deep Learning verbundenen Berechnungen. In diesem Beispiel wird die Verarbeitungszeit von ein paar Stunden auf ein paar Minuten verkürzt.
Sie können das in diesem Artikel beschriebene Modell auch in einer Docker-Umgebung installieren und verwenden. Zur Installation siehe TensorFlow mit Docker auf einer virtuellen Maschine mit vGPU auf CODE-DE FRA1-1 installieren und Beispiel für einen Deep-Learning-Workflow mit TensorFlow und Docker auf einer virtuellen Maschine mit vGPU auf CODE-DE.
Die Aufgabe, auf die Sie TensorFlow anwenden werden, besteht darin, zu erkennen, welche Bildsätze zurechtgeschnitten sind und welche nicht. In den beiden unten gezeigten Bildsätzen sind die Bilder auf der linken Seite nicht beschnitten, während die Bilder auf der rechten Seite beschnitten sind. Das Modell, das Sie in diesem Artikel entwickeln werden, wird in der Lage sein, (mehr oder weniger) die gleichen Schlussfolgerungen zu ziehen wie ein Mensch für den gleichen Satz von Bildern.
Warnung
Die Verarbeitung von Satellitenbildern ist eine eigene Disziplin, bei der verschiedene Techniken zum Einsatz kommen. Dieser Artikel konzentriert sich auf die absoluten Grundlagen, um das Konzept und einen möglichen Arbeitsablauf beim Einsatz von Deep Learning auf einer vGPU-Maschine zu demonstrieren.
Außerdem ist das hier entwickelte Modell nur ein Beispiel. Die Verwendung in der Produktion würde umfangreiche weitere Tests erfordern. Das Modell ist nicht deterministisch und wird bei jedem Training andere Ergebnisse liefern.
Was wir tun werden
Gründliche Erläuterung des in diesem Prozess verwendeten Python-Codes.
Herunterladen von Daten zum Testen und Trainieren.
Kopieren der Daten und des Python-Code auf eine GPU-fähige virtuelle Maschine
Installieren von erforderlichen Abhängigkeiten (pandas und numpy).
Anwenden des Modells mit den Daten, die für diesen Artikel verwendet werden.
Analysieren der Ergebnisse.
Testen des Modells auf den Flavors vm.a6000.1 und vm.a6000.8 , Vergleich der Prozessierungsdauer.
Voraussetzungen
Nr. 1 Konto
Sie benötigen ein CODE-DE Konto mit Zugriff auf die Horizon-Schnittstelle: https://cloud.fra1-1.cloudferro.com/auth/login/?next=/.
Nr. 2 Erstellen einer neuen Linux-VM mit virtueller NVIDIA-GPU
So erstellen Sie eine Linux-VM mit virtueller NVIDIA-GPU: Wie erstellt man eine neue Linux-VM mit NVIDIA Virtual GPU im OpenStack Dashboard (Horizon)?.
Nr. 3 Fügen Sie Ihrer VM eine floating IP Addresse hinzu
/networking/How-to-Add-or-Remove-Floating-Ips-to-your-VM-on-CODE-DE.
Jetzt können Sie diese floating IP-Adresse für die Beispiele in diesem Artikel verwenden.
Nr. 4 TensorFlow installieren
Sie müssen auch TensorFlow installiert haben. Eine Anleitung dazu finden Sie im folgenden Artikel: TensorFlow auf ei er FRA1-1 vGPU-fähiger VM auf CODE-DE installieren. Der vorliegende Beitrag ist eine direkte Fortsetzung dieses Artikels.
Nr. 5 Lokal auf einem Ubuntu 20.04 LTS Computer ausführen
Dieser Artikel geht davon aus, dass auf Ihrem lokalen Computer Ubuntu 20.04 LTS läuft. Sie können dieses Modell jedoch auch von jedem anderen Betriebssystem aus ausführen, vorausgesetzt, Sie verwenden die entsprechenden Befehle für Dateioperationen, SSH-Zugriff und so weiter.
Code Erläuterung
Dieser Abschnitt enthält eine ausführliche Erläuterung des Verfahrens und des dafür verwendeten Python-Codes. Für die praktischen Schritte, mit denen Sie diesen Arbeitsablauf nachvollziehen können, beginnen Sie bitte mit dem Abschnitt Praktischer Arbeitsablauf (siehe unten). Sie müssen den Python-Code nicht selbst kopieren, eine entsprechende Datei steht für Sie zum Download bereit.
Schritt 1: Datenvorbereitung
Die Datenvorbereitung ist der grundlegende (und in der Regel zeitaufwändigste) Schritt in jedem Data Science-Projekt. Damit unser DL-Modell in der Lage ist zu lernen, werden wir die typische (überwachte) Lernsequenz befolgen:
Organisieren Sie eine ausreichend große Datenmenge (hier: eine Sentinel-2-Beispielszene).
Manuelle Kennzeichnung dieser Daten (durch einen Menschen). In unserem Beispiel haben wir die Bilder manuell in die Kategorien „edges“ und „noedges“ eingeteilt, die jeweils für beschnittene und nicht beschnittene Bilder stehen.
Ein Teil dieser Daten wird als Train(+Validation)-Teilmenge beiseite gelegt, die zum „Anlernen“ des Modells verwendet wird.
Eine andere Teilmenge wird als Test beiseite gelegt. Dabei handelt es sich um eine Kontrollgruppe, die das Modell während der Lernphase nie zu Gesicht bekommt und die zur Bewertung der Modellqualität verwendet wird.
Die herunterladbare .zip Datei, die Sie weiter unten in diesem Artikel finden, ist ein bereits vorbereiteter Datensatz (gemäß diesen Schritten). Sie enthält
592 Dateien des Train/Validate-Sets (50/50 beschnittene/nicht beschnittene Bilder)
148 Dateien des Testsatzes (ebenfalls 50/50 beschnitten/nicht beschnitten).
Basierend auf den Namen der Ordner und Unterordner dieses Datensatzes wird Keras automatisch die Beschriftungen vornehmen, daher ist es wichtig, die Ordnerstruktur beizubehalten.
Der letzte Schritt besteht darin, die notwendigen Operationen an den Daten durchzuführen, damit sie eine geeignete Eingabe für das Modell darstellen. TensorFlow wird einen großen Teil dieser Arbeit für uns erledigen. Zum Beispiel wird mit der Funktion image_dataset_from_directory jedes Bild automatisch beschriftet und in einen Vektor/Matrix von Zahlen umgewandelt: Höhe x Breite x Tiefe (RGB-Ebene).
Für Ihren speziellen Anwendungsfall müssen Sie möglicherweise verschiedene Optimierungen der Daten in diesem Schritt vornehmen.
import numpy as np
import tensorflow as tf
from tensorflow import keras
import pandas as pd
# DATEN BEREITSTELLUNG
# -------------------------------------------------------------------------------------
# Bereitstellen der Trainings-, Validierungs- und Testdatensätze aus Bildordnern.
# Die Labels (edges vs. noedges) werden automatisch aus den Ordnernamen abgeleitet.
train_ds = keras.utils.image_dataset_from_directory(
directory='./data/train',
labels='inferred',
label_mode='categorical',
validation_split=0.2,
subset='training',
image_size=(343, 343),
seed=123,
batch_size=8)
val_ds = keras.utils.image_dataset_from_directory(
directory='./data/train',
labels='inferred',
label_mode='categorical',
validation_split=0.2,
subset='validation',
image_size=(343, 343),
seed=123,
batch_size=8)
test_ds = keras.utils.image_dataset_from_directory(
directory='./data/test',
labels='inferred',
label_mode='categorical',
image_size=(343, 343),
shuffle = False,
batch_size=1)
Schritt 2: Definieren und Trainieren des Modells
Die Definition eines optimalen Modells ist eine zentrale Herausforderung in der Datenwissenschaft. Was wir hier zeigen, ist lediglich ein einfaches Beispielmodell. Sie sollten in anderen Quellen mehr über die Erstellung von Modellen für reale Szenarien lesen.
Sobald das Modell definiert ist, wird es kompiliert und sein Training beginnt. Jede Epoche ist die nächste Iteration bei der Abstimmung des Modells. Diese Epochen sind komplexe und rechenintensive Operationen. Die Verwendung von vGPU ist für Deep-Learning-Anwendungen von grundlegender Bedeutung, da sie die Verteilung von Mikroaufgaben auf Hunderte von Kernen ermöglicht und so den Prozess immens beschleunigt.
Sobald das Modell angepasst ist, werden wir es speichern und für die Erstellung von Vorhersagen wiederverwenden.
# TRAINING
# -------------------------------------------------------------------------------------
# Build, compile and fit the Deep Learning model
model = keras.applications.Xception(
weights=None, input_shape=(343, 343, 3), classes=2)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics='accuracy')
model.fit(train_ds, epochs=5, validation_data=val_ds)
model.save('model_save.h5')
# to reuse the model later:
#model = keras.models.load_model('model_save.h5')
Schritt 3: Generierung von Vorhersagen für die Testdaten
Sobald das Modell trainiert wurde, ist die Erstellung der Vorhersagen ein einfacher und viel schnellerer Vorgang. Wie zuvor beschrieben, werden wir das Modell verwenden, um Vorhersagen für die Testdaten zu erstellen.
# GENERATE PREDICTIONS on previously unseen data
# -------------------------------------------------------------------------------------
predictions_raw = model.predict(test_ds)
Schritt 4: Zusammenfassung der Resultate
In diesem Schritt nehmen wir die tatsächlichen Beschriftungen („edges“ vs. „noedges“, die „beschnittene“ vs. „nicht beschnittene“ Bilder darstellen) und vergleichen sie mit den Beschriftungen, die unser Modell vorhergesagt hat.
Wir fassen die Ergebnisse in einem Datensatz zusammen, der als CSV-Datei gespeichert wird und die Interpretation der tatsächlichen Ergebnisse in der Testmenge im Vergleich zu den vom Modell gelieferten Vorhersagen ermöglicht.
Beispiel für die CSV-Ausgabe:
# SUMMARIZE RESULTS (convenience, alterantive approaches are available)
# -------------------------------------------------------------------------------------
# initialize pandas dataframe with file paths
df = pd.DataFrame(data = {"file_path": test_ds.file_paths})
class_names = test_ds.class_names # ["edges","noedges"]
# add actual labels column
def get_actual_label(label_vector):
for index, value in enumerate(label_vector):
if (value == 1):
return class_names[index]
actual_label_vectors = np.concatenate([label for data, label in test_ds], axis=0).tolist() # returns array of label vectors [[0,1],[1,0],...] representing category (edges/noedges)
actual_labels = list(map(lambda alv: get_actual_label(alv), actual_label_vectors))
df["actual_label"] = actual_labels
# add predicted labels column
predictions_binary = np.argmax(predictions_raw, axis=1) # flatten to 0-1 recommendation
predictions_labeled = list(map(lambda x: class_names[0] if x == 0 else class_names[1],list(predictions_binary)))
df["predicted_label"] = predictions_labeled
df.to_csv("results.csv", index=False)
Praktischer Arbeitsablauf
Dieser Abschnitt enthält praktische Schritte, mit denen Sie diesen Arbeitsablauf selbst durchführen können. Dies ist nur ein Beispiel und Sie können selbst einen anderen Arbeitsablauf erstellen.
Bitte lesen Sie noch einmal den Abschnitt Voraussetzungen, bevor Sie die folgenden praktischen Schritte durchführen.
Schritt 1: Laden und Formatieren der Daten
Trennen Sie die Verbindung zu Ihrer virtuellen Maschine, falls Sie dies noch nicht getan haben, indem Sie den folgenden Befehl verwenden:
exit
Öffnen Sie Ihren Internet-Browser und laden Sie die benötigten Dateien herunter:
Schritt 2: Kopieren Sie die heruntergeladenen Dateien auf Ihre virtuelle Maschine
Für die Zwecke dieses Artikels gehen wir davon aus, dass Ihr Browser die oben genannten Dateien in den Ordner Downloads in Ihrem Home-Verzeichnis heruntergeladen hat. Wenn Ihr Browser anders konfiguriert ist, ändern Sie die folgenden Anweisungen entsprechend.
Öffnen Sie Ihr Terminal auf Ihrem lokalen Rechner und machen Sie den Ordner Downloads zu Ihrem aktuellen Arbeitsverzeichnis:
cd Downloads
Verwenden Sie den Befehl scp, um die Dateien auf Ihren virtuellen Rechner zu kopieren (ersetzen Sie 64.225.129.70 durch die IP-Adresse Ihres Rechners):
scp ./data.zip ./deeplearning.py [email protected]:/home/eouser/
Schritt 3: Installieren Sie zusätzliche erforderliche Pakete
Verbinden Sie sich erneut über SSH mit Ihrer virtuellen Maschine (ersetzen Sie 64.225.129.70 durch die IP-Adresse Ihrer Maschine):
Gehen Sie erneut in Ihre virtuelle Python-Umgebung (diejenige, die Sie im vorangegangenen Artikel erstellt haben) TensorFlow auf ei er FRA1-1 vGPU-fähiger VM auf CODE-DE installieren).
source tensorflowenv/bin/activate
Installieren Sie nun die erforderlichen Bibliotheken:
pip install numpy
pip install pandas
Schritt 4: Vorbereiten der Dateien
Erstellen Sie den Ordner, in dem Sie die für den Deep-Learning-Prozess erforderlichen Dateien ablegen werden - für die Zwecke dieses Artikels wird er deeplearning genannt:
mkdir deeplearning
Verschieben Sie die erforderlichen Dateien in diesen Ordner:
mv deeplearning.py data.zip deeplearning
Machen Sie den Ordner deeplearning zu Ihrem aktuellen Arbeitsverzeichnis:
cd deeplearning
Entpacken Sie die Datei, die die Daten enthält:
unzip data.zip
Sie können nun das ursprüngliche Zip-Archiv entfernen:
rm data.zip
Verwenden Sie den Befehl ls, um zu überprüfen, ob Ihr Ordner deeplearning die folgenden Dateien enthält:
directory data (content of the above mentioned ZIP archive)
text file deeplearning.py
Schritt 5: Führen Sie den Python-Code aus
Führen Sie nun die Textdatei mit dem Python-Code mit dem folgenden Befehl aus:
python3 deeplearning.py
Sobald die Operationen abgeschlossen sind, sollten eine Textdatei results.csv (mit den Ergebnissen) und eine Datei model_save.h5 (mit dem soeben trainierten Modell) in Ihrem aktuellen Arbeitsverzeichnis erschienen sein - überprüfen Sie deren Existenz mit dem Befehl ls.
Schritt 6: Laden Sie die Ergebnisse und das trainierte Modell auf Ihren lokalen Computer herunter
Trennen Sie zunächst die Verbindung zu Ihrer virtuellen Maschine mit dem folgenden Befehl:
exit
Machen Sie den Ordner, in den Sie die Datei herunterladen möchten, zu Ihrem aktuellen Arbeitsverzeichnis und stellen Sie sicher, dass er noch keine Datei mit dem Namen results.csv oder model_save.h5 enthält. Sie können die Dateien nun mit dem folgenden Befehl herunterladen (ersetzen Sie 64.225.129.70 durch die freie IP-Adresse Ihres virtuellen Rechners):
scp [email protected]:/home/eouser/deeplearning/results.csv [email protected]:/home/eouser/deeplearning/model_save.h5 .
Ihre Dateien sollten sich jetzt auf Ihrem lokalen Rechner befinden:
Leistungsvergleich
In diesem Artikel wird TensforFlow direkt auf FRA1-1 Cloud installiert. Es gibt einen parallelen Artikel mit demselben Beispiel, das auf Docker läuft (Beispiel für einen Deep-Learning-Workflow mit TensorFlow und Docker auf einer virtuellen Maschine mit vGPU auf CODE-DE). Wir werden nun die Laufzeiten dieser Umgebungen vergleichen, indem wir die kleinste und die größte Variante für vGPUs, vm.a6000.1 und vm.a6000.8, verwenden.
Die folgende Tabelle enthält die Zeit, die für die Ausführung des Python-Codes benötigt wird. Sie wurde mit dem Befehl time („real value“) gemessen. Alle Tests wurden auf CODE-DE FRA1-1 ausgeführt.
vm.a6000.1 |
vm.a6000.8 |
|
mit Docker |
5m50.449s |
1m14.446s |
ohne Docker |
5m0.276s |
0m55.547s |
Der gesamte Prozess war auf der vm.a6000.8-Variante etwa fünfmal schneller als auf der vm.a6000.1-Variante. Es gibt einen kleinen Nachteil bei der Verwendung von Docker, aber das ist zu erwarten.
Bemerkung
Bei diesem Benchmark werden alle Phasen der Ausführung des Python-Codes gezählt und nicht alle profitieren in gleichem Maße von besserer Hardware.
Was als nächstes getan werden kann
In diesem Artikel wird TensforFlow direkt auf FRA1-1 Cloud installiert. Es gibt einen parallelen Artikel mit demselben Beispiel, das auf Docker läuft: Beispiel für einen Deep-Learning-Workflow mit TensorFlow und Docker auf einer virtuellen Maschine mit vGPU auf CODE-DE.
Warnung
Die Beispiele in diesem Artikel sind möglicherweise nicht repräsentativ und Ihr Ergebnis kann variieren. Verwenden Sie diesen Code und den gesamten Artikel als Ausgangspunkt für Ihre eigenen Untersuchungen.