Deep Learning Bilderkennung

Bilderkennung

Die Bilderkennung ist eine Technologie, die "Dinge" und "Merkmale" wie Zeichen und Gesichter erkennt, die in Bildern und Videos erscheinen.

Insbesondere Klassifizierung von Bildern, Schätzung der Position von Objekten (obere Abbildung), Flächenteilung von Bildern (untere Abbildung) usw. Es gibt verschiedene Erkennungstechnologien.

2012 kündigte ein Team der University of Toronto eine Studie zur hochpräzisen Bilderkennung mithilfe von Deep Learning an. Das Interesse an tiefem Lernen hat zugenommen, und jetzt werden Zeichenerkennung, Gesichtserkennung, automatisches Fahren, Heimroboter usw. Es wird in verschiedenen Bereichen in die Praxis umgesetzt.

In diesem Beitrag heißt es CNN (Convolutional Neural Network) Ich werde die Technologie lernen.

CNN

Übersicht über CNN

Was ist CNN (Convolutional Neural Network)?

Dies ist ein neuronales Netzwerk, das Merkmale mithilfe einer Schicht extrahiert, die als "Faltschicht" bezeichnet wird und eine ähnliche Struktur wie das Gesichtsfeld des menschlichen Gehirns aufweist.

Im Vergleich zu dem vollständig verbundenen neuronalen Netzwerk, das nur aus Schichten besteht und im Deep Learning Basics-Kurs erlernt wurde Zeigt eine höhere Leistung in Bereichen wie der Bilderkennung.

Die Faltungsschicht ist eine Schicht, die Merkmale auf die gleiche Weise wie die vollständig verbundene Schicht extrahiert, jedoch im Gegensatz zur vollständig verbundenen Schicht. Weil es Bilddaten verarbeiten kann, die zweidimensional bleiben, und Merkmale extrahieren kann Es eignet sich hervorragend zum Extrahieren zweidimensionaler Merkmale wie Linien und Ecken.

Auch in CNN, oft mit einer Faltungsschicht

Eine Schicht, die als "Pooling-Schicht" bezeichnet wird, wird verwendet.

Die Pooling-Schicht reduziert die aus der Faltungsschicht erhaltenen Informationen Schließlich werden die Bilder klassifiziert.

In der nächsten Sitzung lernen wir jede Ebene kennen, erstellen ein CNN-Modell wie in Abb. 2 gezeigt und klassifizieren die Bilder tatsächlich.

Faltschicht

Wie in der Figur gezeigt, ist die Faltungsschicht eine Schicht, die sich auf einen Teil der Eingabedaten konzentriert und die Eigenschaften dieses Teilbildes untersucht.

Auf welche Art von Merkmalen konzentriert werden sollte, wird durch geeignete Definition von Trainingsdaten und Verlustfunktionen bestimmt. Es wird automatisch gelernt.

Zum Beispiel im Fall von CNN, das Gesichter erkennt, wenn das Lernen richtig voranschreitet In der Faltungsschicht nahe der Eingangsschicht ist dies ein Merkmal niedrigdimensionaler Konzepte wie Linien und Punkte. Ebenen, die näher an der Ausgabeebene liegen, konzentrieren sich auf höherdimensionale konzeptionelle Merkmale wie Augen und Nase.

(Tatsächlich werden Konzepte höherer Ordnung wie Augen und Nase nicht direkt aus dem ursprünglichen Eingabebild erkannt. Sie wird basierend auf der Positionskombination von Konzepten niedriger Ordnung erkannt, die in der Schicht nahe der Eingabeebene erkannt wurden. )

Eine bemerkenswerte Funktion wird als Gewichtsmatrix behandelt, die im Programm als Filter (Kernel) bezeichnet wird. Verwenden Sie für jede Funktion einen Filter.

In der folgenden Abbildung für ein Bild von 9 x 9 x 3 (vertikal x horizontal x Anzahl der Kanäle (3 Kanäle von R, G, B)) Es sieht aus wie Falten mit einem 3x3x3-Filter (vertikal x horizontal x Anzahl der Kanäle).

Ich erstelle eine neue 4x4x1-Feature-Map (wie ein Schwarzweißbild) mit einem 3x3x3-Filter. Verwenden Sie außerdem mehrere verschiedene Filter, um insgesamt N 4x4x1-Karten zu erstellen. Insgesamt transformiert diese Faltungsschicht ein 9x9x3-Bild in eine 4x4xN-Feature-Map.

(Einschließlich der folgenden Probleme in dieser Sitzung wird häufig ein zweidimensionales Filter als Beispiel zur Erläuterung der Faltungsschicht verwendet. In der Realität wird jedoch häufig ein dreidimensionales Filter verwendet, wie in der folgenden Abbildung dargestellt. .)

Klicken Sie hier für ein einfaches Implementierungsbeispiel Lassen Sie es uns implementieren, ohne Keras + TensorFlow zu verwenden.

import numpy as np
import matplotlib.pyplot as plt
import urllib.request

#Definiert eine sehr einfache Faltungsschicht
class Conv:
    #Für ein einfaches Beispiel ist W auf 3x3 festgelegt, nicht auf Schritte oder Auffüllen für spätere Sitzungen.
    def __init__(self, W):
        self.W = W
    def f_prop(self, X):
        out = np.zeros((X.shape[0]-2, X.shape[1]-2))
        for i in range(out.shape[0]):
            for j in range(out.shape[1]):
                x = X[i:i+3, j:j+3]
                #Ich nehme die Summe der Produkte für jedes Element
                out[i,j] = np.dot(self.W.flatten(), x.flatten())
        return out

X = np.load('./5100_cnn_data/circle.npy')

plt.imshow(X)
plt.title("base image", fontsize=12)
plt.show()

#Bitte stellen Sie den Kernel richtig ein
W1 = np.array([[0,1,0],
               [0,1,0],
               [0,1,0]])

W2 = np.array([[0,0,0],
               [1,1,1],
               [0,0,0]])
W3 = np.array([[1,0,0],
               [0,1,0],
               [0,0,1]])
W4 = np.array([[0,0,1],
               [0,1,0],
               [1,0,0]])

plt.subplot(1,4,1); plt.imshow(W1)
plt.subplot(1,4,2); plt.imshow(W2)
plt.subplot(1,4,3); plt.imshow(W3)
plt.subplot(1,4,4); plt.imshow(W4)
plt.suptitle("kernels", fontsize=12)
plt.show()

#Falten
conv1 = Conv(W1); C1 = conv1.f_prop(X)
conv2 = Conv(W2); C2 = conv2.f_prop(X)
conv3 = Conv(W3); C3 = conv3.f_prop(X)
conv4 = Conv(W4); C4 = conv4.f_prop(X)

plt.subplot(1,4,1); plt.imshow(C1)
plt.subplot(1,4,2); plt.imshow(C2)
plt.subplot(1,4,3); plt.imshow(C3)
plt.subplot(1,4,4); plt.imshow(C4)
plt.suptitle("convolution results", fontsize=12)
plt.show()

Pooling-Schicht

Wie in der Abbildung gezeigt, ist die Pooling-Schicht eine Schicht, die die Ausgabe der Faltungsschicht und die Datenmenge reduziert.

Wie in der Abbildung gezeigt

Max Pooling:Nehmen Sie den Maximalwert eines Unterabschnitts der Feature-Map
Durchschnittliches Pooling:Nehmen Sie den Durchschnitt der speziellen Karte
Daten können auf diese Weise komprimiert werden.

Sie können die Verteilung der Merkmale im Bild untersuchen, indem Sie die Faltung durchführen, die in der Sitzung "Faltschicht" behandelt wurde. Dieselben Funktionen werden häufig gruppiert und an ähnlichen Orten verteilt Darüber hinaus gibt es Zeiten, in denen Orte, an denen Features nicht gefunden werden können, weit verbreitet sind. Die von der Faltungsschicht ausgegebene Merkmalskarte ist für die Größe ihrer Daten verschwenderisch.

Durch Pooling kann die Verschwendung solcher Daten verringert und die Daten komprimiert werden, während der Informationsverlust verringert wird.

Andererseits werden die detaillierten Positionsinformationen durch Pooling gelöscht. Im Gegenteil, dies bedeutet, dass die von der Pooling-Ebene extrahierten Merkmale nicht durch die parallele Bewegung des Originalbilds beeinflusst werden.

Es spielt eine Rolle bei der Bereitstellung von Robustheit.

Wenn Sie beispielsweise handgeschriebene Zahlen in einem Foto klassifizieren, ist die Position der Zahlen nicht wichtig. Durch das Pooling werden solche weniger wichtigen Informationen entfernt Sie können ein Modell erstellen, das gegenüber Änderungen der Position des zu erkennenden Objekts in Bezug auf das Eingabebild resistent ist.

Die folgende Abbildung zeigt eine Feature-Map mit 5 x 5 (vertikal x horizontal), die alle 3 x 3 (vertikal x horizontal) zusammengefasst wird.

Max Pooling

Durchschnittliches Pooling

Klicken Sie hier für eine einfache Implementierung

import numpy as np
import matplotlib.pyplot as plt
import urllib.request

#Es definiert eine sehr einfache Faltungsschicht.
class Conv:
    #Für ein einfaches Beispiel ist W auf 3x3 festgelegt und wir denken nicht an Schritte oder Auffüllen für spätere Sitzungen.
    def __init__(self, W):
        self.W = W
    def f_prop(self, X):
        out = np.zeros((X.shape[0]-2, X.shape[1]-2))
        for i in range(out.shape[0]):
            for j in range(out.shape[1]):
                x = X[i:i+3, j:j+3]
                out[i,j] = np.dot(self.W.flatten(), x.flatten())
        return out

#Es definiert eine sehr einfache Pooling-Ebene.
class Pool:
    #Für ein einfaches Beispiel werden Schritte oder Auffüllungen für spätere Sitzungen nicht berücksichtigt.
    def __init__(self, l):
        self.l = l
    def f_prop(self, X):
        l = self.l
        out = np.zeros((X.shape[0]//l, X.shape[1]//l))
        for i in range(out.shape[0]):
            for j in range(out.shape[1]):
                #Führen Sie Max Pooling mit dem folgenden Code durch.
                out[i,j] = np.max(X[i*l:(i+1)*l, j*l:(j+1)*l])
        return out

X = np.load('./5100_cnn_data/circle.npy')

plt.imshow(X)
plt.title("base image", fontsize=12)
plt.show()

#Kernel
W1 = np.array([[0,1,0],
               [0,1,0],
               [0,1,0]])
W2 = np.array([[0,0,0],
               [1,1,1],
               [0,0,0]])
W3 = np.array([[1,0,0],
               [0,1,0],
               [0,0,1]])
W4 = np.array([[0,0,1],
               [0,1,0],
               [1,0,0]])

#Falten
conv1 = Conv(W1); C1 = conv1.f_prop(X)
conv2 = Conv(W2); C2 = conv2.f_prop(X)
conv3 = Conv(W3); C3 = conv3.f_prop(X)
conv4 = Conv(W4); C4 = conv4.f_prop(X)

plt.subplot(1,4,1); plt.imshow(C1)
plt.subplot(1,4,2); plt.imshow(C2)
plt.subplot(1,4,3); plt.imshow(C3)
plt.subplot(1,4,4); plt.imshow(C4)
plt.suptitle("convolution images", fontsize=12)
plt.show()

#Pooling
pool = Pool(2)
P1 = pool.f_prop(C1)
P2 = pool.f_prop(C2)
P3 = pool.f_prop(C3)
P4 = pool.f_prop(C4)

plt.subplot(1,4,1); plt.imshow(P1)
plt.subplot(1,4,2); plt.imshow(P2)
plt.subplot(1,4,3); plt.imshow(P3)
plt.subplot(1,4,4); plt.imshow(P4)
plt.suptitle("pooling results", fontsize=12)
plt.show()

Die untere Abbildung ist das Ergebnis des maximalen Pooling.

Implementierung von CNN

Implementieren Sie CNN mit Keras + TensorFlow.

In der Praxis verwenden Sie diese Bibliotheken meistens, um Ihr Modell zu implementieren. Erstellen Sie in Keras zunächst eine Instanz, die das Modell verwaltet, und definieren Sie die Ebenen mithilfe der Add-Methode Schicht für Schicht.

Erstellen Sie eine Instanz.

model = Sequential()

Fügen Sie Ebenen des Modells Schicht für Schicht hinzu, indem Sie die unten gezeigte Add-Methode verwenden. Die vollständig verbundene Schicht wurde wie folgt definiert.

model.add(Dense(128))

Fügen Sie die Faltungsschicht wie folgt hinzu. Sie werden die Parameter in einer späteren Sitzung lernen.

model.add(Conv2D(filters=64, kernel_size=(3, 3)))

Fügen Sie die Pooling-Ebene wie folgt hinzu. Sie werden die Parameter in einer späteren Sitzung lernen.

model.add(MaxPooling2D(pool_size=(2, 2)))

Schließlich wird das neuronale Netzwerkmodell kompiliert und die Generierung abgeschlossen.

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

Im Folgenden wird eine Tabelle mit der betreffenden Modellstruktur ausgegeben.

model.summary()

Klicken Sie hier für ein einfaches Beispiel

from keras.layers import Activation, Conv2D, Dense, Flatten, MaxPooling2D
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical

#Modelldefinition
model = Sequential()

#Implementierungsbeispiel
# --------------------------------------------------------------
model.add(Conv2D(input_shape=(28, 28, 1), filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding="same"))
model.add(Conv2D(filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(1,1)))
# --------------------------------------------------------------
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('sigmoid'))
model.add(Dense(128))
model.add(Activation('sigmoid'))
model.add(Dense(10))
model.add(Activation('softmax'))

model.summary()

Klassifizierung mit CNN (MNIST)

MNIST ist ein Datensatz handgeschriebener Zahlen, wie in der folgenden Abbildung dargestellt. Jedes Bild ist 28 x 28 Pixel groß und besteht aus 1-Kanal-Daten (monochrom). Jeder hat eine Klassenbezeichnung von 0-9.

Wir werden CNN verwenden, um den MNIST-Datensatz zu klassifizieren.

Klicken Sie hier für ein Implementierungsbeispiel

from keras.datasets import mnist
from keras.layers import Dense, Dropout, Flatten, Activation
from keras.layers import Conv2D, MaxPooling2D
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical
from keras.utils.vis_utils import plot_model
import numpy as np
import matplotlib.pyplot as plt

#Lade Daten
(X_train, y_train), (X_test, y_test) = mnist.load_data()

#Dieses Mal werden wir 300 Daten für das Training und 100 Daten für das Testen verwenden.
#Die Conv-Schicht empfängt ein 4-dimensionales Array. (Stapelgröße x Länge x Breite x Anzahl der Kanäle)
#Da es sich bei den MNIST-Daten ursprünglich um 3D-Daten und nicht um ein RGB-Bild handelt, werden sie im Voraus in 4D konvertiert.
X_train = X_train[:300].reshape(-1, 28, 28, 1)
X_test = X_test[:100].reshape(-1, 28, 28, 1)
y_train = to_categorical(y_train)[:300]
y_test = to_categorical(y_test)[:100]

#Modelldefinition
model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(3, 3),input_shape=(28,28,1)))
model.add(Activation('relu'))
model.add(Conv2D(filters=64, kernel_size=(3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))


model.compile(loss='categorical_crossentropy',
              optimizer='adadelta',
              metrics=['accuracy'])

model.fit(X_train, y_train,
          batch_size=128,
          epochs=1,
          verbose=1,
          validation_data=(X_test, y_test))

#Bewertung der Genauigkeit
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])

#Datenvisualisierung (erste 10 Blatt Testdaten)
for i in range(10):
    plt.subplot(2, 5, i+1)
    plt.imshow(X_test[i].reshape((28,28)), 'gray')
plt.suptitle("10 images of test data",fontsize=20)
plt.show()

#Vorhersage (erste 10 Blatt Testdaten)
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print(pred)

model.summary()

Klassifizierung mit CNN (CIFAR-10)

CIFAR-10 (Cipher Ten) ist ein Datensatz von Bildern, die 10 Arten von Objekten zeigen, wie in der folgenden Abbildung gezeigt.

Jedes Bild ist 32 x 32 Pixel groß und verfügt über 3 Datenkanäle (R, G, B). Jeder hat eine Klassenbezeichnung von 0-9. Die Objekte, die jeder Klassenbezeichnung entsprechen, sind wie folgt.

0: Flugzeug 1: Automobil 2: Vogel 3: Cat 4: Hirsch 5: Hund 6: Frosch 7: Pferd 8: Schiff 9: LKW Wir werden CNN verwenden, um den CIFAR-10-Datensatz zu klassifizieren.

import keras
from keras.datasets import cifar10
from keras.layers import Activation, Conv2D, Dense, Dropout, Flatten, MaxPooling2D
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt

#Lade Daten
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

#Dieses Mal werden wir 300 aller Daten für das Training und 100 zum Testen verwenden.
X_train = X_train[:300]
X_test = X_test[:100]
y_train = to_categorical(y_train)[:300]
y_test = to_categorical(y_test)[:100]


#Modelldefinition
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))


#kompilieren
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(loss='categorical_crossentropy',
              optimizer=opt,
              metrics=['accuracy'])

#Das Erlernen dauert einige Minuten. Laden Sie daher die durch das Training erhaltenen Gewichte im Voraus.
#model.load_weights('./cnn_data/param_cifar10.hdf5')

#Lernen
model.fit(X_train, y_train, batch_size=32, epochs=1)

#Verwenden Sie Folgendes, um Gewichte zu sparen. Es kann hier nicht ausgeführt werden.
# model.save_weights('param_cifar10.hdf5')

#Bewertung der Genauigkeit
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])

#Datenvisualisierung (erste 10 Blatt Testdaten)
for i in range(10):
    plt.subplot(2, 5, i+1)
    plt.imshow(X_test[i])
plt.suptitle("10 images of test data",fontsize=20)
plt.show()

#Vorhersage (erste 10 Blatt Testdaten)
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print(pred)

model.summary()

Hyperparameter

Filter (Conv-Schicht)

Der Filterparameter für die Faltungsschicht ist
Gibt die Anzahl der zu generierenden Feature-Maps an, dh die Art der zu extrahierenden Features.

In der Abbildung unten Filter sind 20 in der ersten Faltungsschicht Die Filter werden sogar in der zweiten Faltungsschicht 20 sein.

Wenn die Filter zu klein sind, um die erforderlichen Funktionen zu extrahieren, können Sie nicht gut lernen. Wenn es jedoch zu groß ist, kann es leicht zu einem Überlernen kommen. Seien Sie also vorsichtig.

Lassen Sie es uns implementieren, ohne Keras + TensorFlow zu verwenden.

import numpy as np
import matplotlib.pyplot as plt

#Es definiert eine sehr einfache Faltungsschicht.
#Es wird nur eine 1-Kanal-Bildfaltung angenommen.
#Für ein einfaches Beispiel ist der Kernel auf 3x3 festgelegt, nicht auf Schritte oder Polsterung.
class Conv:
    def __init__(self, filters):
        self.filters = filters
        self.W = np.random.rand(filters,3,3)
    def f_prop(self, X):
        out = np.zeros((filters, X.shape[0]-2, X.shape[1]-2))
        for k in range(self.filters):
            for i in range(out[0].shape[0]):
                for j in range(out[0].shape[1]):
                    x = X[i:i+3, j:j+3]
                    out[k, i, j] = np.dot(self.W[k].flatten(), x.flatten())
        return out

X = np.load('./5100_cnn_data/circle.npy')

filters=10

#Erzeugung einer Faltungsschicht
conv = Conv(filters=filters)

#Durchführung der Faltung
C = conv.f_prop(X)

# --------------------------------------------------------------
#Unten finden Sie den gesamten Code für die Visualisierung.
# --------------------------------------------------------------

plt.imshow(X)
plt.title('base image', fontsize=12)
plt.show()

plt.figure(figsize=(5,2))
for i in range(filters):
    plt.subplot(2,filters/2,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv.W[i])
plt.suptitle('kernels', fontsize=12)
plt.show()

plt.figure(figsize=(5,2))
for i in range(filters):
    plt.subplot(2,filters/2,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C[i])
plt.suptitle('convolution results', fontsize=12)
plt.show()

kernel_size (Conv-Ebene)

Der Parameter kernel_size der Faltungsschicht ist Gibt die Größe des Kernels an (die für die Faltung verwendete Gewichtsmatrix).

Wie oben erwähnt, wird die Feature-Map durch den Satz von Produkten der Eingabedaten und des Kernels bestimmt. Die folgende Abbildung zeigt einen 3x3-Kernel. Jedes Element erhält eine beliebige Zahl für eine optimale Faltung.

In der folgenden Abbildung beträgt kernel_size für die erste Faltungsschicht 5 x 5.

Wenn kernel_size zu klein ist, können selbst sehr kleine Features nicht erkannt werden und das Lernen kann nicht gut verlaufen.

Im Gegenteil, wenn es zu groß ist, sollte es als Sammlung kleiner Merkmale erkannt worden sein. Auch große Merkmale werden erkannt

Nutzen Sie nicht die Stärke des neuronalen Netzwerkmodells, das sich gut für die Erfassung hierarchischer Strukturen eignet Es wird ein ineffizientes Modell sein.

Klicken Sie hier für ein Implementierungsbeispiel

import numpy as np
import matplotlib.pyplot as plt

#Es definiert eine sehr einfache Faltungsschicht.
#Es wird nur eine 1-Kanal-Bildfaltung angenommen.
#Ich denke nicht an Schritte oder Polsterung, weil ich an ein einfaches Beispiel denke.
class Conv:
    def __init__(self, filters, kernel_size):
        self.filters = filters
        self.kernel_size = kernel_size
        self.W = np.random.rand(filters, kernel_size[0], kernel_size[1])
    def f_prop(self, X):
        k_h, k_w = self.kernel_size
        out = np.zeros((filters, X.shape[0]-k_h+1, X.shape[1]-k_w+1))
        for k in range(self.filters):
            for i in range(out[0].shape[0]):
                for j in range(out[0].shape[1]):
                    x = X[i:i+k_h, j:j+k_w]
                    out[k,i,j] = np.dot(self.W[k].flatten(), x.flatten())
        return out

X = np.load('./5100_cnn_data/circle.npy')

#Falten 1
filters = 4
kernel_size = (3,3)

#Erzeugung einer Faltungsschicht
conv1 = Conv(filters=filters, kernel_size=kernel_size)

#Durchführung der Faltung
C1 = conv1.f_prop(X)

#Falten 2
filters = 4
kernel_size = (6,6)

#Erzeugung einer Faltungsschicht
conv2 = Conv(filters=filters, kernel_size=kernel_size)

#Durchführung der Faltung
C2 = conv2.f_prop(X)

#Unten finden Sie den gesamten Code für die Visualisierung

plt.imshow(X)
plt.title('base image', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv1.W[i])
plt.suptitle('kernel visualization', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C1[i])
plt.suptitle('convolution results 1', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv2.W[i])
plt.suptitle('kernel visualization', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C2[i])
plt.suptitle('convolution results 2', fontsize=12)
plt.show()

Schritte (Conv-Schicht)

Der Schrittparameter der Faltungsschicht ist das Intervall, in dem Merkmale extrahiert werden. Mit anderen Worten, geben Sie die Entfernung an, um die der Kernel verschoben werden soll.

strides=(1,1)

strides=(2,2)

Je kleiner die Schritte sind, desto feiner können die Merkmale extrahiert werden. Beispielsweise wird dasselbe Merkmal an derselben Stelle im Bild mehrmals erkannt. Es scheint, dass es viele nutzlose Berechnungen gibt.

Es wird jedoch allgemein gesagt, dass kleinere Schritte besser sind. Strides ist standardmäßig (1,1) in der Conv2D-Ebene von Keras.

import numpy as np
import matplotlib.pyplot as plt

#Es definiert eine sehr einfache Faltungsschicht.
#Es wird nur eine 1-Kanal-Bildfaltung angenommen.
#Ich denke nicht an Polsterung, weil ich an ein einfaches Beispiel denke.
class Conv:
    def __init__(self, filters, kernel_size, strides):
        self.filters = filters
        self.kernel_size = kernel_size
        self.strides = strides
        self.W = np.random.rand(filters, kernel_size[0], kernel_size[1])
    def f_prop(self, X):
        k_h = self.kernel_size[0]
        k_w = self.kernel_size[1]
        s_h = self.strides[0]
        s_w = self.strides[1]
        out = np.zeros((filters, (X.shape[0]-k_h)//s_h+1, (X.shape[1]-k_w)//s_w+1))
        for k in range(self.filters):
            for i in range(out[0].shape[0]):
                for j in range(out[0].shape[1]):
                    x = X[i*s_h:i*s_h+k_h, j*s_w:j*s_w+k_w]
                    out[k,i,j] = np.dot(self.W[k].flatten(), x.flatten())
        return out

X = np.load('./5100_cnn_data/circle.npy')

#Falten 1
filters = 4
kernel_size = (3,3)
strides = (1,1)

#Erzeugung einer Faltungsschicht
conv1 = Conv(filters=filters, kernel_size=kernel_size, strides=strides)

#Durchführung der Faltung
C1 = conv1.f_prop(X)

#Falten 2
filters = 4
kernel_size = (3,3)
strides = (2,2)

#Erzeugung einer Faltungsschicht
conv2 = Conv(filters=filters, kernel_size=kernel_size, strides=strides)
conv2.W = conv1.W #Einheitlicher Kernel

#Durchführung der Faltung
C2 = conv2.f_prop(X)

#Unten finden Sie den gesamten Code für die Visualisierung

plt.imshow(X)
plt.title('base image', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv1.W[i])
plt.suptitle('kernel visualization', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C1[i])
plt.suptitle('convolution results 1', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv2.W[i])
plt.suptitle('kernel results', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C2[i])
plt.suptitle('convolution results 2', fontsize=12)
plt.show()

Polsterung (Conv-Schicht)

Durch Auffüllen soll verhindert werden, dass das Bild beim Falten schrumpft. Hinzufügen von Pixeln um das Eingabebild.

Im Allgemeinen wird das hinzuzufügende Pixel auf 0 gesetzt. Füllen Sie den Bereich um dieses Eingabebild mit 0 Dies wird als Nullauffüllung bezeichnet.

Das Auffüllen berücksichtigt auch die Eigenschaften der Kantendaten. Außerdem wird die Häufigkeit von Datenaktualisierungen zunehmen Es gibt Vorteile wie die Möglichkeit, die Anzahl der Eingabe- / Ausgabeeinheiten für jede Ebene anzupassen.

Der weiße Rahmen um das orangefarbene Feld in der Abbildung unten steht für Polsterung. Dies ist eine Figur mit 1 Polsterung nach oben und unten und 1 Polsterung nach links und rechts.

In der Conv2D-Ebene von Keras Geben Sie die Auffüllmethode an, z. B. padding = valid, padding = same.

padding=Wenn gültig, erfolgt keine Auffüllung
padding=Wenn dies der Fall ist, sollte die Ausgabe-Feature-Map der Größe der Eingabe entsprechen
Der Eingang ist aufgefüllt.

Der gleiche Code verwendet die Auffüllbreite als Argument, z. B. padding = (1,1).

import numpy as np
import matplotlib.pyplot as plt
import urllib.request

#Es definiert eine sehr einfache Faltungsschicht.
#Es wird nur eine 1-Kanal-Bildfaltung angenommen.
class Conv:
    def __init__(self, filters, kernel_size, strides, padding):
        self.filters = filters
        self.kernel_size = kernel_size
        self.strides = strides
        self.padding = padding
        self.W = np.random.rand(filters, kernel_size[0], kernel_size[1])
    def f_prop(self, X):
        k_h, k_w = self.kernel_size
        s_h, s_w = self.strides
        p_h, p_w = self.padding
        out = np.zeros((filters, (X.shape[0]+p_h*2-k_h)//s_h+1, (X.shape[1]+p_w*2-k_w)//s_w+1))
        #Polsterung
        X = np.pad(X, ((p_h, p_h), (p_w, p_w)), 'constant', constant_values=((0,0),(0,0)))
        self.X = X #Speichern Sie es zur späteren Visualisierung der Auffüllergebnisse.
        for k in range(self.filters):
            for i in range(out[0].shape[0]):
                for j in range(out[0].shape[1]):
                    x = X[i*s_h:i*s_h+k_h, j*s_w:j*s_w+k_w]
                    out[k,i,j] = np.dot(self.W[k].flatten(), x.flatten())
        return out

X = np.load('./5100_cnn_data/circle.npy')

#Falten 1
filters = 4
kernel_size = (3,3)
strides = (1,1)
padding = (0,0)

#Erzeugung einer Faltungsschicht
conv1 = Conv(filters=filters, kernel_size=kernel_size, strides=strides, padding=padding)

#Durchführung der Faltung
C1 = conv1.f_prop(X)

#Falten 2
filters = 4
kernel_size = (3,3)
strides = (1,1)
padding = (2,2)

#Erzeugung einer Faltungsschicht
conv2 = Conv(filters=filters, kernel_size=kernel_size, strides=strides, padding=padding)
conv2.W = conv1.W #Das Gewicht ist einheitlich

#Durchführung der Faltung
C2 = conv2.f_prop(X)

#Unten finden Sie den gesamten Code für die Visualisierung.

plt.imshow(conv1.X)
plt.title('padding results of the convolution 1', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv1.W[i])
plt.suptitle('kernel visualization of the convolution 1', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C1[i])
plt.suptitle('results of the convolution 1', fontsize=12)
plt.show()

plt.imshow(conv2.X)
plt.title('padding results of the convolution 2', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(conv2.W[i])
plt.suptitle('kernel visualization of the convolution 2', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C2[i])
plt.suptitle('results of the convolution 2', fontsize=12)
plt.show()

pool_size (Poolebene)

Der Parameter pool_size der Poolebene lautet Ein Parameter, der die Größe des Bereichs angibt, auf den das Pooling gleichzeitig angewendet wird (Pooling-Rauheit).

In der folgenden Abbildung beträgt die erste Poolgröße 2x2 und die zweite Poolgröße ebenfalls 2x2.

Durch Erhöhen von pool_size Erhöhte Robustheit gegenüber der Position (Die Ausgabe ändert sich auch dann nicht, wenn sich die Position, an der das Objekt im Bild erscheint, geringfügig ändert.) Grundsätzlich sollte pool_size 2x2 sein.

import numpy as np
import matplotlib.pyplot as plt

#Es definiert eine sehr einfache Faltungsschicht.
class Conv:
    def __init__(self, W, filters, kernel_size):
        self.filters = filters
        self.kernel_size = kernel_size
        self.W = W # np.random.rand(filters, kernel_size[0], kernel_size[1])
    def f_prop(self, X):
        k_h, k_w = self.kernel_size
        out = np.zeros((filters, X.shape[0]-k_h+1, X.shape[1]-k_w+1))
        for k in range(self.filters):
            for i in range(out[0].shape[0]):
                for j in range(out[0].shape[1]):
                    x = X[i:i+k_h, j:j+k_w]
                    out[k,i,j] = np.dot(self.W[k].flatten(), x.flatten())
        return out

#Es definiert eine sehr einfache Pooling-Ebene.
#Es wird nur das Pooling der 1-Kanal-Feature-Map angenommen.
class Pool:
    def __init__(self, pool_size):
        self.pool_size = pool_size
    def f_prop(self, X):
        k_h, k_w = self.pool_size
        out = np.zeros((X.shape[0]-k_h+1, X.shape[1]-k_w+1))
        for i in range(out.shape[0]):
            for j in range(out.shape[1]):
                out[i,j] = np.max(X[i:i+k_h, j:j+k_w])
        return out

X = np.load('./5100_cnn_data/circle.npy')

W = np.load('./5100_cnn_data/weight.npy') 

#Falten
filters = 4
kernel_size = (3,3)
conv = Conv(W=W, filters=filters, kernel_size=kernel_size)
C = conv.f_prop(X)

#Pooling 1
pool_size = (2,2)
pool1 = Pool(pool_size)
P1 = [pool1.f_prop(C[i]) for i in range(len(C))]

#Pooling 2
pool_size = (4,4)
pool2 = Pool(pool_size)
P2 = [pool2.f_prop(C[i]) for i in range(len(C))]

#Unten finden Sie den gesamten Code für die Visualisierung.

plt.imshow(X)
plt.title('base image', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(C[i])
plt.suptitle('convolution results', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(P1[i])
plt.suptitle('pooling results', fontsize=12)
plt.show()

plt.figure(figsize=(10,1))
for i in range(filters):
    plt.subplot(1,filters,i+1)
    ax = plt.gca() # get current axis
    ax.tick_params(labelbottom="off", labelleft="off", bottom="off", left="off") #Achse löschen
    plt.imshow(P2[i])
plt.suptitle('pooling results', fontsize=12)
plt.show()

Schritte (Poolschicht)

Der Streifenparameter der Poolebene ist Ähnlich wie der Parameter "Schritte der Faltungsschicht" gibt er das Intervall an, in dem die Feature-Map zusammengefasst wird.