Formatieren der Daten für TensorFlow
Teil 1 dieser Blogserie demonstrierte die Vorteile der Verwendung einer relationalen Datenbank zum Speichern und Durchführen von Datenexplorationen von Bildern mithilfe einfacher SQL-Anweisungen. In diesem Tutorial, Teil 2, wird auf die in Teil 1 verwendeten Daten aus einer MariaDB Server-Datenbank zugegriffen und in die von TensorFlow benötigten Datenstrukturen konvertiert. Die Ergebnisse der Anwendung des Modells zur Klassifizierung neuer Bilder werden zur weiteren Analyse in einer relationalen Tabelle gespeichert.
Dies ist ein kurzes Tutorial eines TensorFlow-Programms mit den im Folgenden beschriebenen Details. Wenn Sie mit den grundlegenden Konzepten nicht vertraut sind, ist dieses TensorFlow-Tutorial „Grundlegende Klassifizierung:Bilder von Kleidung klassifizieren“ ein guter Ausgangspunkt. Einige der Beispiele und Codes aus dem Tutorial werden hier verwendet.
Zusätzliche Pakete erforderlich
Einige zusätzliche Pakete werden zum Erstellen und Trainieren des Bildklassifizierungsmodells benötigt:
- Gurke implementiert binäre Protokolle zum Serialisieren und Deserialisieren einer Python-Objektstruktur.
- NumPy bietet Unterstützung für große, mehrdimensionale Arrays und Matrizen sowie mathematische Funktionen auf hoher Ebene, um mit diesen Arrays zu arbeiten.
- TensorFlow ist eine Python-Bibliothek für schnelles numerisches Rechnen. Es ist eine grundlegende Bibliothek, die verwendet werden kann, um Deep-Learning-Modelle direkt oder mithilfe von Wrapper-Bibliotheken zu erstellen, die den auf TensorFlow aufbauenden Prozess vereinfachen.
- Keras ist eine in Python geschriebene Open-Source-Bibliothek für neuronale Netzwerke.
import pickleimport numpy as npimport tensorflow as tffrom tensorflow import kerasprint('Tensorflow version:', tf.__version__)print('Numpy version:', np.__version__)Tensorflow version:2.0.0Numpy version:1.16.2 Bilder abrufen
Nachdem die Pakete importiert wurden, besteht der nächste Schritt darin, die Trainingsbilder aus der Datenbank abzurufen und die Daten in zwei numpy aufzuteilen Arrays. Zuerst müssen wir die Arrays mit Trainingsbildern (train_images) und Trainingslabels (train_labels) initialisieren. Da wir die Bilder bereits vektorisiert haben, können wir das Attribut img_vector verwenden, um das Array train_images mit der folgenden SQL-Anweisung zu füllen.
# Initialisieren Sie die numpy-Arraystrain_images =np.empty((60000,28,28), dtype='uint8')train_labels =np.empty((60000), dtype='uint8')# Rufen Sie die Trainingsbilder aus der ab databasesql="SELECT img_label, img_vector, img_idx \FROM tf_images INNER JOIN img_use ON img_use =use_id \WHERE use_name ='Training'"cur.execute(sql)result =cur.fetchall()# Füllen Sie die numpy-Arrays. Zeile[2] enthält den Bildindex für die Zeile im Ergebnis:nparray =pickle.loads(row[1])train_images[row[2]] =nparraytrain_labels[row[2]] =row[0]
Auf ähnliche Weise können die Bilder zum Testen aus der Datenbank abgerufen werden. Der Nippe In diesem Fall verwendete Arrays sind test_images und test_labels. In diesem Fall sind die Testdaten 10.000 Bilder mit einer Auflösung von 28 x 28 Pixel.
# Initialisieren Sie die numpy-Arraystest_images =np.empty((10000,28,28), dtype='uint8')test_labels =np.empty((10000), dtype='uint8')# Rufen Sie die Testbilder aus der ab databasesql="SELECT img_label, img_vector, img_idx \FROM tf_images INNER JOIN img_use ON img_use =use_id \WHERE use_name ='Testing'"cur.execute(sql)result =cur.fetchall()# Füllen Sie die numpy-Arrays. Zeile[2] enthält den Bildindex für die Zeile im Ergebnis:nparray =pickle.loads(row[1])test_images[row[2]] =nparraytest_labels[row[2]] =row[0]
Schließlich wird jedes Bild einem einzelnen Etikett zugeordnet. Die Label-Namen werden in der Categories-Tabelle gespeichert und in das class_names-Array geladen:
sql="SELECT class_name FROM categorys"cur.execute(sql)class_names =cur.fetchall()
Daten vorverarbeiten
Die Daten müssen vor dem Training des Netzes vorverarbeitet werden. Wenn Sie das erste Bild im Trainingssatz untersuchen, werden Sie sehen, dass die Pixelwerte in den Bereich von 0 bis 255 fallen:
plt.figure()plt.imshow(train_images[0])plt.colorbar()plt.grid(False)plt.show()
oben:Bild aus dem fashion_mnist-Datensatz
Bevor die Bilder dem neuronalen Netzwerkmodell zugeführt werden, müssen die Werte auf einen Bereich von 0 bis 1 skaliert werden. Teilen Sie dazu die Werte durch 255. Es ist wichtig, dass das Trainingsset und das Testset auf die gleiche Weise vorverarbeitet werden .
Sie können matplotlib verwenden um die ersten 25 Bilder anzuzeigen, um zu überprüfen, ob die Daten das richtige Format haben und zum Aufbau und Training des Netzwerks bereit sind:
train_images =train_images / 255.0test_images =test_images / 255.0plt.figure(figsize=(10,10))for i in range(25):plt.subplot(5,5,i+1)plt.xticks([ ])plt.yticks([])plt.grid(False)plt.imshow(train_images[i], cmap=plt.cm.binary)plt.xlabel(class_names[train_labels[i]])plt.show()
oben:Bilder aus dem fashion_mnist-Datensatz
Bauen des Modells
Nachdem die Daten in zwei Teilmengen vorverarbeitet wurden, können Sie mit einem Modelltraining fortfahren. Bei diesem Vorgang wird der Algorithmus mit Trainingsdaten „gefüttert“. Der Algorithmus verarbeitet die Daten und gibt ein Modell aus, das in der Lage ist, einen Zielwert (Attribut) in neuen Daten zu finden – das heißt, das dem neuronalen Netzwerk präsentierte Bild zu klassifizieren.
Die meisten neuronalen Deep-Learning-Netzwerke werden durch die Verkettung einfacher Schichten hergestellt.
Die erste Schicht im Netzwerk wandelt das Bildformat von einem zweidimensionalen Array (von 28 mal 28 Pixel) in ein eindimensionales Array (von 28 * 28 =784 Pixel) um. Diese Ebene hat keine zu lernenden Parameter; es formatiert nur die Daten neu.
Nachdem die Pixel abgeflacht sind, besteht das Netzwerk aus zwei vollständig verbundenen Schichten, die aktiviert werden müssen. In einem neuronalen Netzwerk ist die Aktivierungsfunktion dafür verantwortlich, die summierte gewichtete Eingabe vom Knoten in die Aktivierung des Knotens oder die Ausgabe für diese Eingabe umzuwandeln.
Die erste dichte Schicht hat 128 Knoten (oder Neuronen) und verwendet eine Aktivierungsmethode mit gleichgerichteter linearer Einheit (ReLU). Die gleichgerichtete lineare Aktivierungsfunktion ist eine stückweise lineare Funktion, die die Eingabe direkt ausgibt, wenn sie positiv ist, andernfalls wird sie Null ausgeben.
Die zweite (und letzte) Schicht ist eine 10-Knoten-Softmax-Schicht. Eine Softmax-Funktion gibt einen Vektor aus, der die Wahrscheinlichkeitsverteilungen einer Liste möglicher Ergebnisse darstellt. Es gibt ein Array von 10 Wahrscheinlichkeitswerten zurück, die sich zu 1 summieren. Jeder Knoten enthält einen Wert, der die Wahrscheinlichkeit angibt, dass das aktuelle Bild zu einer der 10 Klassen gehört.
Die meisten Ebenen, wie z. B. tf.keras.layers.Dense, haben Parameter, die während des Trainings gelernt werden.
model =keras.Sequential([keras.layers.Flatten(input_shape=(28, 28)),keras.layers.Dense(128, activation='relu'),keras.layers.Dense(10, activation='softmax')])
Das Modell kompilieren
Der Modellkompilierungsschritt wird verwendet, um einige weitere Einstellungen hinzuzufügen, bevor es für das Training bereit ist. In diesem Fall sind die folgenden Einstellungen aktiviert.
- Optimierer – Aktualisiert das Modell basierend auf den angezeigten Daten und seiner Verlustfunktion (siehe unten).
- Verlustfunktion – Misst, wie genau das Modell während des Trainings ist. Sie möchten diese Funktion minimieren, um das Modell in die richtige Richtung zu „lenken“.
- Metriken – Überwachen Sie die Trainings- und Testschritte. Das folgende Beispiel verwendet die Genauigkeit, den Anteil der korrekt klassifizierten Bilder.
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
Modell trainieren
Das Trainieren des neuronalen Netzwerkmodells erfordert die folgenden Schritte.
- Feed die Trainingsdaten an das Modell.
- Das Modell lernt, Bilder und Labels zuzuordnen.
- Prognosen zu einem Testsatz treffen.
- Vergewissern Sie sich, dass die Vorhersagen mit den Labels aus dem test_labels-Array übereinstimmen.
Um mit dem Training zu beginnen, rufen Sie die Methode model.fit auf – so genannt, weil sie das Modell an die Trainingsdaten „anpasst“:
model.fit(train_images, train_labels, epochs=10)Trainiere auf 60000 BeispielenEpoche 1/1060000/60000 [==============================] - 5s 83us/Probe - Verlust:0,4964 - Genauigkeit:0,8236Epoche 2/1060000/60000 [==============================] - 4s 65us/Probe - Verlust:0,3735 - Genauigkeit:0,8642Epoche 3/1060000/60000 [=============================] - 3s 55us/Probe - Verlust:0,3347 - Genauigkeit:0,8773Epoche 4/1060000/60000 [==============================] - 3s 56us/Probe - Verlust:0,3106 - Genauigkeit:0,8861Epoche 5/1060000/60000 [==============================] - 3s 58us/Probe - Verlust:0,2921 - Genauigkeit:0,8924s - Verlust:0,2928 - Genauigkeit - ETA:0s - Verlust:0,2925 - GenauigkeitEpoch 6/1060000/60000 [==============================] - 3s 57us/Probe - Verlust:0,2796 - Genauigkeit:0,8969sEpoche 7/1060000/60000 [=============================] - 4s 70us/Probe - Verlust:0,2659 - Genauigkeit:0,9007Epoch 8/1060000/60000 [=============================] - 4s 61us/Probe - Verlust:0,2548 - Genauigkeit:0,9042Epoche 9/1060000/60000 [ =============================] - 4s 61us/Probe - Verlust:0,2449 - Genauigkeit:0,9084Epoche 10/1060000/60000 [=============================] - 5s 76us/Probe - Verlust:0,2358 - Genauigkeit:0,9118
Am Ende jeder Epoche wird das neuronale Netzwerk anhand des Validierungssatzes bewertet. Darauf beziehen sich Verlust und Genauigkeit.
Genauigkeit bewerten und vorhersagen
Um die Gesamtgenauigkeit des Modells abzuschätzen, berechnen Sie den Durchschnitt aller zehn Vorkommen des Genauigkeitswerts, in diesem Fall 88 %.
Führen Sie dann model.evaluate aus auf dem Test-Set, um die Vorhersagegenauigkeit des trainierten neuronalen Netzwerks auf zuvor ungesehenen Daten zu erhalten.
test_loss, test_acc =model.evaluate(test_images, test_labels, verbose=2)10000/1 – 0s – Verlust:0,2766 – Genauigkeit:0,8740
Der Testdatensatz ist weniger genau als der Trainingsdatensatz. In diesem Fall stellt diese Lücke zwischen Trainingsgenauigkeit und Testgenauigkeit eine Überanpassung dar. Das Gegenteil ist Underfitting. Wenn Sie mehr über dieses Thema erfahren möchten, empfehle ich Overfitting vs. Underfitting:A Conceptual Explanation von Will Koehrsen.
An dieser Stelle können wir einige Vorhersagen über die Bilder in unserem Trainingsdatensatz treffen.
predictions =model.predict(test_images)predictions[0]array([1.90860412e-08, 8.05085235e-11, 1.56402713e-08, 1.66699390e-10,7.86950158e-11, 4.33062996e-06, 2.490.490e -08, 1.20656565e-02, 3.80084719e-09, 9.87929940e-01], dtype=float32)
Die Ausgabe von model.predict ist ein Array aus 10 Zahlen mit der Wahrscheinlichkeit, dass eine Instanz zu jeder Klasse gehört. Es ist eine gute Idee, die Ergebnisse in der MariaDB-Datenbank für weitere Analysen und Berichte zu speichern. Unten sehen Sie ein Beispiel dafür, wie Sie das Vorhersagearray durchlaufen, um ein Tupel zu erstellen und es dann in prediction_results einzufügen Tabelle.
sql ="INSERT INTO optimize_results (img_idx, img_use, T_shirt_Top, Hose, Pullover, Dress, Coat, Sandal, Shirt, Sneaker, Bag, Ankle_boot, label)VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);"i =0 für Zeile in Vorhersagen:insert_tuple =(str(i), str(2), str (Zeile[0]), str(Zeile[1]), str(Zeile[2]), str(Zeile[3]), str(Zeile[4]), str(Zeile[5]), str(Zeile [6]), str(Zeile[7]), str(Zeile[8]), str(Zeile[9]), str(test_labels[i]))cur.execute(sql, insert_tuple)conn.commit() i +=1
Auch hier kann eine einfache SQL-Anweisung verwendet werden, um zu überprüfen, ob die Daten geladen wurden.
sql ="SELECT T_shirt_Top, Hose, Pullover, Dress, Coat, Sandal, Shirt, Sneaker, Bag, Ankle_boot, class_name as 'Test Label'FROM Vorhersage_Ergebnisse JOIN Kategorien ON label =class_idx WHERE img_idx =1"display( pd. read_sql(sql,conn) )
| T_shirt_Top | Hose | Pullover | Kleid | Mantel | Sandale | Hemd | Sneaker | Tasche | Ankle_boot | Testetikett |
| 0,00001 | 0,0 | 0,997912 | 0,0 | 0,001267 | 0,0 | 0,00081 | 0,0 | 0,0 | 0,0 | Pullover |
Erstellen von Vorhersagen
Ein paar Plotfunktionen zum Anzeigen der Vorhersagen sind unten definiert (Grafikfunktionen).
Lassen Sie uns ein neues Bild aus dem Testsatz abrufen und die Klassifizierung des neuronalen Netzes basierend auf der Vorhersagewahrscheinlichkeit anzeigen.
sql ="SELECT img_idx, Label FROM Vorhersage_Ergebnisse WO img_idx =1"cur.execute(sql)result =cur.fetchone()plt.figure(figsize=(6,3))plt.subplot(1,2, 1)plot_image(Ergebnis[0], Vorhersagen[Ergebnis[0]], Test_Labels, Test_Bilder)plt.subplot(1,2,2)plot_value_array(Ergebnis[0], Vorhersagen[Ergebnis[0]], Test_Labels)plt. zeigen()
oben:Bild aus dem fashion_mnist-Datensatz
In diesem Fall konnte das Modell das Bild mit 100-prozentiger Genauigkeit richtig klassifizieren. Lassen Sie uns als Nächstes eine Abfrage ausführen, um die ersten 15 Bilder aus dem Testsatz abzurufen und sie zu klassifizieren.
sql ="SELECT img_idx, Label FROM Vorhersage_Ergebnisse LIMIT 15"Anzahl_Zeilen =5Anzahl_Spalten =3plt.figure(figsize=(2*2*Anzahl_Spalten, 2*Anzahl_Zeilen))cur.execute(sql)result =cur.fetchall() für Zeile im Ergebnis:plt.subplot(Anzahl_Zeilen, 2*Anzahl_Spalten, 2*Zeile[0]+1)plot_image(Zeile[0], Vorhersagen[Zeile[0]], Test_Labels, Test_Bilder)plt.subplot(Anzahl_Zeilen, 2 *num_cols, 2*row[0]+2)plot_value_array(row[0], Vorhersagen[row[0]], test_labels)plt.tight_layout()plt.show()
oben:Bilder aus dem fashion_mnist-Datensatz
Wie Sie sehen können, gibt es Fälle, in denen das Modell falsch sein kann, wie in der letzten Zeile, linken Spalte gezeigt. In diesem Fall wurde ein Sneaker als Sandale (in Rot) klassifiziert.
Zusammenfassung
Obwohl die Integration zwischen TensorFlow und MariaDB Server einfach ist, sind die Vorteile dieser Integration beträchtlich:
- Die Verwendung relationaler Daten beim maschinellen Lernen kann die Implementierungskomplexität verringern. Data Scientists und Data Engineers können gleichermaßen eine gemeinsame Sprache verwenden, um Data Wrangling- und Exploration-Aufgaben auszuführen.
- Effizienzgewinne beim Zugreifen, Aktualisieren, Einfügen, Manipulieren und Modifizieren von Daten können die Markteinführung beschleunigen.
- Die Möglichkeit, die Ergebnisse des Modells wieder in der Datenbank zu speichern, ermöglicht es Endbenutzern und Analysten, Abfragen und Berichte mit benutzerfreundlichen Berichtstools wie Tableau auszuführen.
MIT-Lizenz
Der von diesem Blog genutzte Datensatz Fashion MNIST (fashion_mnist) ist unter der MIT-Lizenz lizenziert, Copyright © 2017 Zalando SE, https://tech.zalando.com
Der von diesem Blog genutzte Quellcode ist aus dem Tutorial „Grundlegende Klassifizierung:Bilder von Kleidung klassifizieren“ angepasst, das unter der MIT-Lizenz lizenziert ist, Copyright (c) 2017 François Chollet.
Hiermit wird jeder Person, die eine Kopie dieser Software und der dazugehörigen Dokumentationsdateien (die „Software“) erhält, kostenlos die Erlaubnis erteilt, uneingeschränkt mit der Software zu handeln, einschließlich, aber nicht beschränkt auf die Rechte zur Nutzung, Vervielfältigung, Änderung und Zusammenführung , Kopien der Software zu veröffentlichen, zu verteilen, unterzulizenzieren und/oder zu verkaufen und Personen, denen die Software zur Verfügung gestellt wird, dies zu gestatten, vorbehaltlich der folgenden Bedingungen:
Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
DIE SOFTWARE WIRD OHNE MÄNGELGEWÄHR BEREITGESTELLT, OHNE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF GEWÄHRLEISTUNGEN DER MARKTFÄHIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG VON RECHTEN DRITTER. DIE AUTOREN ODER URHEBERRECHTSINHABER SIND IN KEINEM FALL HAFTBAR FÜR ANSPRÜCHE, SCHÄDEN ODER SONSTIGE HAFTUNG, OB IN EINER VERTRAGSAKTION, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE SICH AUS, AUS ODER IM ZUSAMMENHANG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN HANDLUNGEN IN DER SOFTWARE ERGEBEN SOFTWARE.
Referenzen
Konvertieren Sie Ihr eigenes Bild in das Bild von MNIST
matplotlib:Bild-Tutorial
5 Wege, wie KI das Kundenerlebnis verändert
Digitalisierung erfindet das Geschäft neu
Was ist Bildklassifizierung?
Einführung in Python Deep-Learning-Bibliothek TensorFlow
Grafikfunktionen
def plot_image(i, Vorhersagen_Array, wahres_Label, Bild):Vorhersagen_Array, wahres_Label, Bild =Vorhersagen_Array, wahres_Label[i], img[i]plt.grid(False)plt.xticks([])plt.yticks([ ])plt.imshow(img, cmap=plt.cm.binary)predicted_label =np.argmax(predictions_array)if predicted_label ==true_label:color ='blue'else:color ='red'plt.xlabel("{} { :2.0f}% ({})".format(class_names[predicted_label],100*np.max(predictions_array),class_names[true_label]),color=color)def plot_value_array(i, Vorhersagen_array, true_label):predictions_array, true_label =Vorhersage_Array, True_Label[i]plt.grid(False)plt.xticks(Bereich(10))plt.yticks([])thisplot =plt.bar(Bereich(10), Vorhersage_Array, Farbe="#777777")plt .ylim([0, 1])predicted_label =np.argmax(predictions_array)thisplot[predicted_label].set_color('red')thisplot[true_label].set_color('blue') 
