Keras - Faltungs-Neuronales Netz

Lassen Sie uns das Modell von MPL auf ändern Convolution Neural Network (CNN) für unser früheres Problem der Ziffernidentifikation.

CNN kann wie folgt dargestellt werden -

Die Hauptmerkmale des Modells sind wie folgt:

Die Eingabeebene besteht aus (1, 8, 28) Werten.
Erste Schicht, Conv2D besteht aus 32 Filtern und einer 'relu'-Aktivierungsfunktion mit Kernelgröße (3,3).
Zweite Schicht, Conv2D besteht aus 64 Filtern und einer 'relu'-Aktivierungsfunktion mit Kernelgröße (3,3).
Dünne Schicht, MaxPooling hat Poolgröße von (2, 2).
Fünfte Schicht, Flatten wird verwendet, um alle Eingaben in eine einzige Dimension zu reduzieren.
Sechste Schicht, Dense besteht aus 128 Neuronen und 'Relu'-Aktivierungsfunktion.
Siebte Schicht, Dropout hat 0,5 als Wert.
Die achte und letzte Schicht besteht aus 10 Neuronen und der Softmax-Aktivierungsfunktion.
Verwenden categorical_crossentropy als Verlustfunktion.
Verwenden Adadelta() als Optimierer.
Verwenden accuracy als Metriken.
Verwenden Sie 128 als Stapelgröße.
Verwenden Sie 20 als Epochen.

Step 1 − Import the modules

Importieren wir die notwendigen Module.

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 
import numpy as np

Step 2 − Load data

Importieren wir den Mnist-Datensatz.

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

Step 3 − Process the data

Lassen Sie uns den Datensatz entsprechend unserem Modell ändern, damit er in unser Modell eingespeist werden kann.

img_rows, img_cols = 28, 28 

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 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

Die Datenverarbeitung ähnelt dem MPL-Modell mit Ausnahme der Form der Eingabedaten und der Konfiguration des Bildformats.

Step 4 − Create the model

Lassen Sie uns das eigentliche Modell erstellen.

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(10, activation = 'softmax'))

Step 5 − Compile the model

Lassen Sie uns das Modell mit ausgewählten Verlustfunktionen, Optimierern und Metriken kompilieren.

model.compile(loss = keras.losses.categorical_crossentropy, 
   optimizer = keras.optimizers.Adadelta(), metrics = ['accuracy'])

Step 6 − Train the model

Lassen Sie uns das Modell mit trainieren fit() Methode.

model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 12, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

Beim Ausführen der Anwendung werden die folgenden Informationen ausgegeben:

Train on 60000 samples, validate on 10000 samples Epoch 1/12 
60000/60000 [==============================] - 84s 1ms/step - loss: 0.2687 
- acc: 0.9173 - val_loss: 0.0549 - val_acc: 0.9827 Epoch 2/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0899 
- acc: 0.9737 - val_loss: 0.0452 - val_acc: 0.9845 Epoch 3/12 
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0666 
- acc: 0.9804 - val_loss: 0.0362 - val_acc: 0.9879 Epoch 4/12 
60000/60000 [==============================] - 81s 1ms/step - loss: 0.0564 
- acc: 0.9830 - val_loss: 0.0336 - val_acc: 0.9890 Epoch 5/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0472 
- acc: 0.9861 - val_loss: 0.0312 - val_acc: 0.9901 Epoch 6/12 
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0414 
- acc: 0.9877 - val_loss: 0.0306 - val_acc: 0.9902 Epoch 7/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0375 
-acc: 0.9883 - val_loss: 0.0281 - val_acc: 0.9906 Epoch 8/12 
60000/60000 [==============================] - 91s 2ms/step - loss: 0.0339 
- acc: 0.9893 - val_loss: 0.0280 - val_acc: 0.9912 Epoch 9/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325 
- acc: 0.9901 - val_loss: 0.0260 - val_acc: 0.9909 Epoch 10/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0284 
- acc: 0.9910 - val_loss: 0.0250 - val_acc: 0.9919 Epoch 11/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0287 
- acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9916 Epoch 12/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0265 
- acc: 0.9920 - val_loss: 0.0249 - val_acc: 0.9922

Step 7 − Evaluate the model

Lassen Sie uns das Modell anhand von Testdaten bewerten.

score = model.evaluate(x_test, y_test, verbose = 0) 

print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

Wenn Sie den obigen Code ausführen, werden die folgenden Informationen ausgegeben:

Test loss: 0.024936060590433316 
Test accuracy: 0.9922

Die Testgenauigkeit beträgt 99,22%. Wir haben ein bestes Modell erstellt, um die Handschriftziffern zu identifizieren.

Step 8 − Predict

Schließlich prognostizieren Sie die Ziffer aus Bildern wie folgt -

pred = model.predict(x_test) 
pred = np.argmax(pred, axis = 1)[:5] 
label = np.argmax(y_test,axis = 1)[:5] 

print(pred) 
print(label)

Die Ausgabe der obigen Anwendung ist wie folgt:

[7 2 1 0 4] 
[7 2 1 0 4]

Die Ausgabe beider Arrays ist identisch und zeigt an, dass unser Modell die ersten fünf Bilder korrekt vorhersagt.