[PYTHON] CNN (1) zur Bildklassifizierung (für Anfänger)

Obwohl es in der Praxis nicht gehandhabt wird, wird es als Lernen aufgezeichnet. Diesmal ist das Convolutional Neural Network (CNN) Es scheint für die Bilderkennungsanalyse effektiv zu sein ...

CNN Der Punkt ist, dass es zusätzlich zum normalen neuronalen Netzwerk eine Faltungsschicht und eine Poolschicht gibt.

Falten

Der wichtigste Teil beim Konvertieren von Features in Daten aus Bildern. Bilddaten sind 5x5x1 Daten. Stellen Sie die Gewichtung im 3x3x3-Kernel ein und berechnen Sie alle Muster. 9 Muster in der Abbildung unten. Das Ergebnis wird als Feature-Map bezeichnet.

Pooling

Pooling ist eine Methode, um ein großes Bild zu verkleinern und gleichzeitig wichtige Informationen zu hinterlassen. Infolgedessen kann die Dimension der Daten verringert werden, die Berechnungsgeschwindigkeit kann unterdrückt werden und das Lernen kann fortgesetzt werden. Es gibt zwei Arten ・ Max Pooling → Legen Sie den Maximalwert im Kernel fest ・ Durchschnittliches Pooling → Berechnen Sie den Durchschnittswert aller Zahlen im Kernel

Spezifische Reduzierung der Datendimension (= Komprimierungsmethode)

Durch das Falten wird die Anzahl der Dimensionen reduziert (= komprimiert), indem die Bilddaten innerhalb der Größe des Kernels berechnet und eine neue Feature-Menge extrahiert werden. Die Formel lautet wie folgt. Durch das Pooling werden die Daten komprimiert, während die Funktionen hervorgehoben werden. Die Methode besteht darin, den Maximalwert im Kernel oder den Durchschnittswert zu berechnen.

Bewegen Sie die Probe

Verwenden Sie den MNIST-Datensatz.

%matplotlib inline
import keras
from keras.datasets import mnist
import matplotlib.pyplot as plt

#Daten lesen. Unterteilt in Trainingsdaten und Trainingsdaten
(x_train, y_train), (x_test, y_test) = mnist.load_data()

#Anzeige von MNIST-Daten
fig = plt.figure(figsize=(9, 9))
fig.subplots_adjust(left=0, right=1, bottom=0, top=0.5, hspace=0.05, wspace=0.05)
for i in range(81):
    ax = fig.add_subplot(9, 9, i + 1, xticks=[], yticks=[])
    ax.imshow(x_train[i].reshape((28, 28)), cmap='gray')

Es kommt so heraus.

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K

batch_size = 128
num_classes = 10
epochs = 12
img_rows, img_cols = 28, 28

(x_train, y_train), (x_test, y_test) = mnist.load_data()

if K.image_data_format() == 'channels_first':
    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

y_train = y_train.astype('int32')
y_test = y_test.astype('int32')
y_train = keras.utils.np_utils.to_categorical(y_train, num_classes)
y_test =  keras.utils.np_utils.to_categorical(y_test, num_classes)

#Der Teil, der vom Falten zum Poolen geht
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))

model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs,
          verbose=1, validation_data=(x_test, y_test))

Zusammenfassung

Das konzeptionelle Bild wurde organisiert.

Referenz

Mechanismus des Faltungsnetzwerks (https://postd.cc/how-do-convolutional-neural-networks-work/) [Was ist ein Faltungsnetzwerk, das häufig in der Bildverarbeitung verwendet wird] (https://kenyu-life.com/2019/03/07/convolutional_neural_network/)