Keras - Jaringan Neural Konvolusi

Mari kita ubah model dari MPL menjadi Convolution Neural Network (CNN) untuk masalah identifikasi digit sebelumnya.

CNN dapat direpresentasikan seperti di bawah ini -

Fitur inti dari model ini adalah sebagai berikut -

Lapisan masukan terdiri dari (1, 8, 28) nilai.
Lapisan pertama, Conv2D terdiri dari 32 filter dan fungsi aktivasi 'relu' dengan ukuran kernel, (3,3).
Lapisan kedua, Conv2D terdiri dari 64 filter dan fungsi aktivasi 'relu' dengan ukuran kernel, (3,3).
Lapisan ketiga, MaxPooling memiliki ukuran kolam (2, 2).
Lapisan kelima, Flatten digunakan untuk meratakan semua masukannya menjadi satu dimensi.
Lapisan keenam, Dense terdiri dari 128 neuron dan fungsi aktivasi 'relu'.
Lapisan ketujuh, Dropout memiliki 0,5 sebagai nilainya.
Lapisan kedelapan dan terakhir terdiri dari 10 neuron dan fungsi aktivasi 'softmax'.
Menggunakan categorical_crossentropy sebagai fungsi kerugian.
Menggunakan Adadelta() sebagai Pengoptimal.
Menggunakan accuracy sebagai metrik.
Gunakan 128 sebagai ukuran batch.
Gunakan 20 sebagai epoch.

Step 1 − Import the modules

Mari kita impor modul yang diperlukan.

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

Mari kita impor dataset mnist.

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

Step 3 − Process the data

Mari kita ubah dataset sesuai dengan model kita, sehingga bisa dimasukkan ke dalam model kita.

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)

Pengolahan datanya mirip dengan model MPL kecuali bentuk data masukan dan konfigurasi format gambar.

Step 4 − Create the model

Mari kita buat model yang sebenarnya.

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

Mari kita kompilasi model menggunakan fungsi kerugian, pengoptimal, dan metrik yang dipilih.

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

Step 6 − Train the model

Mari kita latih modelnya menggunakan fit() metode.

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

Menjalankan aplikasi akan menampilkan informasi di bawah ini -

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

Mari kita evaluasi model menggunakan data uji.

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

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

Menjalankan kode di atas akan menampilkan informasi di bawah ini -

Test loss: 0.024936060590433316 
Test accuracy: 0.9922

Akurasi tes adalah 99,22%. Kami telah membuat model terbaik untuk mengidentifikasi angka tulisan tangan.

Step 8 − Predict

Terakhir, prediksi digit dari gambar seperti di bawah ini -

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

print(pred) 
print(label)

Output dari aplikasi di atas adalah sebagai berikut -

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

Output dari kedua larik identik dan ini menunjukkan bahwa model kita memprediksi lima gambar pertama dengan benar.