1. Hinweis
In diesem Codelab lernen Sie mehr über Faltungen und ihre Bedeutung für maschinelles Sehen.
Im vorherigen Codelab haben Sie ein einfaches Deep Neural Network (DNN) für die Computervision von Modeartikeln entwickelt. Da die Bekleidung das einzige Element auf dem Bild war, sollte es zentriert werden.
Natürlich ist dies ein realistisches Szenario. DNN muss den Bekleidungsartikel auf Bildern mit anderen Objekten erkennen können oder wo er sich vorn und in der Mitte befindet. Dazu sind Faltungen erforderlich.
Voraussetzungen
Dieses Codelab baut auf der Arbeit auf, die in zwei Raten zu sehen war: Ein Hoch auf die Machine Learning-Funktionen und ein Modell für maschinelles Sehen erstellen. Bitte fülle diese Codelabs aus, bevor du fortfährst.
Lerninhalte
- Was sind Faltungen?
- Featurezuordnung erstellen
- Was ist Pooling?
Inhalte, die Sie erstellen werden
- Eine Funktionskarte eines Bilds
Voraussetzungen
Sie finden den Code für den Rest des Codelabs, das in Colab ausgeführt wird.
Außerdem müssen TensorFlow und die Bibliotheken installiert sein, die Sie im vorherigen Codelab installiert haben.
2. Was sind Faltungen?
Eine Faltung ist ein Filter, der ein Bild übergibt, verarbeitet und die wichtigen Merkmale extrahiert.
Angenommen, Sie haben ein Bild einer Person, die einen Sneaker trägt. Wie würden Sie erkennen, dass auf dem Bild ein Turnschuh zu sehen ist? Damit dein Bild als Sneaker angezeigt wird, musst du die wichtigen Funktionen extrahieren und die unwichtigen Merkmale unkenntlich machen. Das nennt man die Funktionszuordnung.
Die Funktionszuordnung ist theoretisch ganz einfach. Sie scannen jedes Pixel im Bild und sehen sich dann die Nachbarpixel an. Multipliziere die Werte dieser Pixel mit der entsprechenden Gewichtung in einem Filter.
Beispiel:
In diesem Fall ist eine 3 x 3-Faltungsmatrix, also ein Bildkern, angegeben.
Der aktuelle Pixelwert ist 192. Sie können den Wert des neuen Pixel berechnen, indem Sie sich die Werte der benachbarten Pixel ansehen, diese mit den im Filter angegebenen Werten multiplizieren und den neuen Pixelwert zum endgültigen Betrag machen.
Im Folgenden wird gezeigt, wie die Faltung funktioniert, indem eine grundlegende Faltung auf einem Graustufenbild in 2D erstellt wird.
Das heben Sie dann das Bild von SciPy zu. und verfügt über ein schönes integriertes Bild mit vielen Winkeln und Linien.
3. Mit dem Programmieren beginnen
Zuerst importieren Sie einige Python-Bibliotheken und das Kletterbild:
import cv2
import numpy as np
from scipy import misc
i = misc.ascent()
Verwenden Sie als Nächstes die Pyplot-Bibliothek matplotlib, um das Bild zu zeichnen und so zu wissen, wie es aussieht:
import matplotlib.pyplot as plt
plt.grid(False)
plt.gray()
plt.axis('off')
plt.imshow(i)
plt.show()
Wie Sie sehen, ist es ein Bild einer Treppe. Es gibt viele Funktionen, die Sie ausprobieren und isolieren können. Beispielsweise gibt es starke vertikale Linien.
Das Bild wird als NumPy-Array gespeichert, sodass wir das transformierte Bild durch Kopieren dieses Arrays erstellen können. Die Variablen „size_x“ und „size_y“ enthalten die Abmessungen des Bildes, sodass Sie es später in einer Schleife wiedergeben können.
i_transformed = np.copy(i)
size_x = i_transformed.shape[0]
size_y = i_transformed.shape[1]
4. Faltungsmatrix erstellen
Erstellen Sie zuerst eine Faltungsmatrix (oder einen Kernel) als 3x3-Array:
# This filter detects edges nicely
# It creates a filter that only passes through sharp edges and straight lines.
# Experiment with different values for fun effects.
#filter = [ [0, 1, 0], [1, -4, 1], [0, 1, 0]]
# A couple more filters to try for fun!
filter = [ [-1, -2, -1], [0, 0, 0], [1, 2, 1]]
#filter = [ [-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
# If all the digits in the filter don't add up to 0 or 1, you
# should probably do a weight to get it to do so
# so, for example, if your weights are 1,1,1 1,2,1 1,1,1
# They add up to 10, so you would set a weight of .1 if you want to normalize them
weight = 1
Berechne jetzt die Ausgabepixel. Bewegen Sie das Bild über den Rand des Bilds mit einer Umrandung von 1 Pixel und multiplizieren Sie die einzelnen Nachbarn des aktuellen Pixel mit dem im Filter definierten Wert.
Das heißt, dass sich das aktuelle Pixel daneben und links davon mit dem Element oben links im Filter multipliziert. Multipliziere dann das Ergebnis mit der Gewichtung und sorge dafür, dass das Ergebnis im Bereich von 0 bis 255 liegt.
Abschließend laden Sie den neuen Wert in das umgewandelte Bild:
for x in range(1,size_x-1):
for y in range(1,size_y-1):
output_pixel = 0.0
output_pixel = output_pixel + (i[x - 1, y-1] * filter[0][0])
output_pixel = output_pixel + (i[x, y-1] * filter[0][1])
output_pixel = output_pixel + (i[x + 1, y-1] * filter[0][2])
output_pixel = output_pixel + (i[x-1, y] * filter[1][0])
output_pixel = output_pixel + (i[x, y] * filter[1][1])
output_pixel = output_pixel + (i[x+1, y] * filter[1][2])
output_pixel = output_pixel + (i[x-1, y+1] * filter[2][0])
output_pixel = output_pixel + (i[x, y+1] * filter[2][1])
output_pixel = output_pixel + (i[x+1, y+1] * filter[2][2])
output_pixel = output_pixel * weight
if(output_pixel<0):
output_pixel=0
if(output_pixel>255):
output_pixel=255
i_transformed[x, y] = output_pixel
5. Ergebnisse untersuchen
Stellen Sie jetzt das Bild dar, um die Auswirkungen des Filters zu sehen:
# Plot the image. Note the size of the axes -- they are 512 by 512
plt.gray()
plt.grid(False)
plt.imshow(i_transformed)
#plt.axis('off')
plt.show()
Sehen Sie sich die folgenden Filterwerte und ihre Auswirkungen auf das Bild an.
Mit [-1,0,1,-2,0,2,-1,0,1] erhalten Sie eine sehr starke vertikale Linie:
Mit [-1,-2,-1,0,0,0,1,2,1] erhalten Sie horizontale Linien:
Sehen Sie sich die verschiedenen Werte an. Probieren Sie außerdem Filter mit unterschiedlicher Größe aus, etwa 5 x 5 oder 7 x 7.
6. Pooling
Nachdem Sie nun die wesentlichen Merkmale des Bildes ermittelt haben, was tun Sie als Nächstes? Wie verwenden Sie die resultierende Featurezuordnung, um Bilder zu klassifizieren?
Ähnlich wie bei Faltungen hilft das Pooling bei der Erkennung von Features. Mit Pooling-Ebenen wird die Gesamtmenge an Informationen in einem Bild reduziert. Dabei werden die erkannten Merkmale beibehalten.
Es gibt verschiedene Arten von Pooling, aber Sie verwenden die Bezeichnung „Maximales (Max.) Pooling“.
Bewegen Sie den Mauszeiger auf das Bild und betrachten Sie zu jedem Zeitpunkt das Pixel und die unmittelbaren Nachbarn rechts, unterhalb und rechts darunter. Fügen Sie den größten Teil davon (in diesem Fall den max. Pooling) in das neue Image ein. Das neue Bild ist also ein Viertel der Größe des alten Bilds.
7. Code für das Pooling schreiben
Der folgende Code zeigt einen (2, 2) Pooling. Führen Sie sie aus, um die Ausgabe zu sehen.
Sie sehen, dass das Bild zwar ein Viertel des Originals ist, aber alle Funktionen behält.
new_x = int(size_x/2)
new_y = int(size_y/2)
newImage = np.zeros((new_x, new_y))
for x in range(0, size_x, 2):
for y in range(0, size_y, 2):
pixels = []
pixels.append(i_transformed[x, y])
pixels.append(i_transformed[x+1, y])
pixels.append(i_transformed[x, y+1])
pixels.append(i_transformed[x+1, y+1])
pixels.sort(reverse=True)
newImage[int(x/2),int(y/2)] = pixels[0]
# Plot the image. Note the size of the axes -- now 256 pixels instead of 512
plt.gray()
plt.grid(False)
plt.imshow(newImage)
#plt.axis('off')
plt.show()
Berücksichtige die Achsen dieses Diagramms. Das Bild ist jetzt 256 x 256 Pixel groß und ein Viertel der ursprünglichen Größe. Die erkannten Merkmale wurden optimiert, obwohl sich jetzt weniger Daten im Bild befinden.
8. Glückwunsch
Sie haben Ihr erstes ML-Modell erstellt. Wie Sie Ihre Modelle für maschinelles Sehen weiter verbessern können, erfahren Sie unter Convolutional Neural Networks (CNNs) entwickeln, um das maschinelle Sehen zu verbessern.