Deep Learning dengan Keras - Panduan Cepat

Pembelajaran Mendalam telah menjadi kata kunci dalam beberapa hari terakhir di bidang Kecerdasan Buatan (AI). Selama bertahun-tahun, kami menggunakan Machine Learning (ML) untuk menyebarkan kecerdasan ke mesin. Dalam beberapa hari terakhir, pembelajaran mendalam menjadi lebih populer karena keunggulannya dalam prediksi dibandingkan dengan teknik ML tradisional.

Deep Learning pada dasarnya berarti melatih Jaringan Syaraf Tiruan (JST) dengan data dalam jumlah besar. Dalam pembelajaran mendalam, jaringan belajar dengan sendirinya dan karenanya membutuhkan data yang sangat banyak untuk pembelajaran. Sementara pembelajaran mesin tradisional pada dasarnya adalah sekumpulan algoritme yang mengurai data dan belajar darinya. Mereka kemudian menggunakan pembelajaran ini untuk membuat keputusan yang cerdas.

Sekarang, masuk ke Keras, itu adalah API jaringan neural tingkat tinggi yang berjalan di atas TensorFlow - platform pembelajaran mesin sumber terbuka ujung ke ujung. Menggunakan Keras, Anda dengan mudah mendefinisikan arsitektur ANN yang kompleks untuk bereksperimen pada data besar Anda. Keras juga mendukung GPU, yang menjadi penting untuk memproses data dalam jumlah besar dan mengembangkan model pembelajaran mesin.

Dalam tutorial ini, Anda akan mempelajari penggunaan Keras dalam membangun jaringan neural dalam. Kita akan melihat contoh praktis untuk mengajar. Masalah yang dihadapi adalah mengenali angka tulisan tangan menggunakan jaringan saraf yang dilatih dengan pembelajaran mendalam.

Hanya untuk membuat Anda lebih bersemangat dalam pembelajaran mendalam, di bawah ini adalah tangkapan layar tren Google tentang pembelajaran mendalam di sini -

Seperti yang Anda lihat dari diagram, minat dalam pembelajaran mendalam terus tumbuh selama beberapa tahun terakhir. Ada banyak bidang seperti visi komputer, pemrosesan bahasa alami, pengenalan suara, bioinformatika, desain obat, dan sebagainya, di mana pembelajaran mendalam telah berhasil diterapkan. Tutorial ini akan membantu Anda memulai pembelajaran dalam dengan cepat.

Jadi teruslah membaca!

Seperti yang dikatakan dalam pendahuluan, pembelajaran dalam adalah proses melatih jaringan saraf tiruan dengan sejumlah besar data. Setelah dilatih, jaringan akan dapat memberi kami prediksi pada data yang tidak terlihat. Sebelum saya menjelaskan lebih jauh tentang apa itu pembelajaran dalam, mari kita bahas beberapa istilah yang digunakan dalam melatih jaringan saraf.

Jaringan Neural

Ide jaringan saraf tiruan berasal dari jaringan saraf di otak kita. Jaringan saraf tipikal terdiri dari tiga lapisan - input, output, dan lapisan tersembunyi seperti yang ditunjukkan pada gambar di bawah ini.

Ini juga disebut a shallowjaringan saraf, karena hanya berisi satu lapisan tersembunyi. Anda menambahkan lebih banyak lapisan tersembunyi pada arsitektur di atas untuk membuat arsitektur yang lebih kompleks.

Jaringan Dalam

Diagram berikut menunjukkan jaringan dalam yang terdiri dari empat lapisan tersembunyi, lapisan masukan, dan lapisan keluaran.

Karena jumlah lapisan tersembunyi ditambahkan ke jaringan, pelatihannya menjadi lebih kompleks dalam hal sumber daya yang diperlukan dan waktu yang diperlukan untuk melatih jaringan sepenuhnya.

Pelatihan Jaringan

Setelah Anda menentukan arsitektur jaringan, Anda melatihnya untuk melakukan jenis prediksi tertentu. Melatih jaringan adalah proses menemukan bobot yang tepat untuk setiap tautan di jaringan. Selama pelatihan, data mengalir dari lapisan Input ke Output melalui berbagai lapisan tersembunyi. Karena data selalu bergerak dalam satu arah dari input ke output, kami menyebut jaringan ini sebagai Jaringan Umpan-maju dan kami menyebut propagasi data sebagai Propagasi Teruskan.

Fungsi Aktivasi

Di setiap lapisan, kami menghitung jumlah masukan yang dibobot dan memasukkannya ke fungsi Aktivasi. Fungsi aktivasi membawa nonlinier ke jaringan. Ini hanyalah beberapa fungsi matematika yang membedakan output. Beberapa fungsi aktivasi yang paling umum digunakan adalah sigmoid, hiperbolik, tangen (tanh), ReLU dan Softmax.

Propagasi mundur

Propagasi mundur adalah algoritme untuk pembelajaran yang diawasi. Dalam Backpropagation, kesalahan menyebar ke belakang dari output ke lapisan input. Diberikan fungsi kesalahan, kami menghitung gradien fungsi kesalahan sehubungan dengan bobot yang ditetapkan pada setiap koneksi. Perhitungan hasil gradien berjalan mundur melalui jaringan. Gradien dari lapisan akhir bobot dihitung terlebih dahulu dan gradien dari bobot lapisan pertama dihitung terakhir.

Pada setiap lapisan, penghitungan parsial gradien digunakan kembali dalam penghitungan gradien untuk lapisan sebelumnya. Ini disebut Gradient Descent.

Dalam tutorial berbasis proyek ini, Anda akan menentukan jaringan neural dalam umpan maju dan melatihnya dengan teknik propagasi mundur dan penurunan gradien. Untungnya, Keras memberi kita semua API tingkat tinggi untuk menentukan arsitektur jaringan dan melatihnya menggunakan penurunan gradien. Selanjutnya, Anda akan mempelajari cara melakukan ini di Keras.

Sistem Pengenalan Digit Tulisan Tangan

Dalam proyek mini ini, Anda akan menerapkan teknik yang dijelaskan sebelumnya. Anda akan membuat jaringan saraf pembelajaran mendalam yang akan dilatih untuk mengenali angka tulisan tangan. Dalam proyek pembelajaran mesin apa pun, tantangan pertama adalah mengumpulkan data. Terutama, untuk jaringan pembelajaran yang dalam, Anda membutuhkan data yang sangat banyak. Untungnya, untuk masalah yang kami coba selesaikan, seseorang telah membuat kumpulan data untuk pelatihan. Ini disebut mnist, yang tersedia sebagai bagian dari pustaka Keras. Dataset terdiri dari beberapa gambar 28x28 piksel dengan digit tulisan tangan. Anda akan melatih model Anda pada bagian utama dari kumpulan data ini dan data lainnya akan digunakan untuk memvalidasi model terlatih Anda.

Deskripsi Proyek

Itu mnistdataset terdiri dari 70000 gambar digit tulisan tangan. Beberapa gambar contoh direproduksi di sini untuk referensi Anda

Setiap gambar berukuran 28 x 28 piksel sehingga menjadi total 768 piksel dengan berbagai tingkat skala abu-abu. Sebagian besar piksel cenderung ke arah bayangan hitam sementara hanya sedikit yang berwarna putih. Kami akan menempatkan distribusi piksel ini dalam sebuah array atau vektor. Misalnya, distribusi piksel untuk gambar tipikal dari angka 4 dan 5 ditunjukkan pada gambar di bawah ini.

Jelas, Anda dapat melihat bahwa distribusi piksel (terutama yang cenderung ke arah warna putih) berbeda, ini membedakan digit yang diwakilinya. Kami akan memasukkan distribusi 784 piksel ini ke jaringan kami sebagai inputnya. Output jaringan akan terdiri dari 10 kategori yang mewakili digit antara 0 dan 9.

Jaringan kita akan terdiri dari 4 lapisan - satu lapisan masukan, satu lapisan keluaran, dan dua lapisan tersembunyi. Setiap lapisan tersembunyi akan berisi 512 node. Setiap lapisan terhubung sepenuhnya ke lapisan berikutnya. Saat kami melatih jaringan, kami akan menghitung bobot untuk setiap koneksi. Kami melatih jaringan dengan menerapkan backpropagation dan penurunan gradien yang telah kita bahas sebelumnya.

Dengan latar belakang ini, sekarang mari kita mulai membuat proyek.

Menyiapkan Proyek

Kami akan menggunakan Jupyter melalui Anacondanavigator untuk proyek kami. Karena proyek kami menggunakan TensorFlow dan Keras, Anda perlu menginstalnya di penyiapan Anaconda. Untuk menginstal Tensorflow, jalankan perintah berikut di jendela konsol Anda:

>conda install -c anaconda tensorflow

Untuk menginstal Keras, gunakan perintah berikut -

>conda install -c anaconda keras

Anda sekarang siap untuk memulai Jupyter.

Memulai Jupyter

Saat Anda memulai navigator Anaconda, Anda akan melihat layar pembuka berikut.

Klik ‘Jupyter’untuk memulainya. Layar akan menampilkan proyek yang ada, jika ada, di drive Anda.

Memulai Proyek Baru

Mulai proyek Python 3 baru di Anaconda dengan memilih opsi menu berikut -

File | New Notebook | Python 3

Tangkapan layar dari pilihan menu ditampilkan untuk referensi cepat Anda -

Proyek kosong baru akan muncul di layar Anda seperti yang ditunjukkan di bawah ini -

Ubah nama proyek menjadi DeepLearningDigitRecognition dengan mengklik dan mengedit nama default “UntitledXX”.

Kami pertama kali mengimpor berbagai pustaka yang diperlukan oleh kode dalam proyek kami.

Penanganan Array dan Plotting

Seperti biasa, kami menggunakan numpy untuk penanganan array dan matplotlibuntuk merencanakan. Pustaka ini diimpor dalam proyek kami menggunakan berikut iniimport pernyataan

import numpy as np
import matplotlib
import matplotlib.pyplot as plot

Peringatan yang Menekan

Karena Tensorflow dan Keras terus merevisi, jika Anda tidak menyinkronkan versi yang sesuai dalam proyek, pada waktu proses Anda akan melihat banyak kesalahan peringatan. Saat mereka mengalihkan perhatian Anda dari pembelajaran, kami akan menekan semua peringatan dalam proyek ini. Ini dilakukan dengan baris kode berikut -

# silent all warnings
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='3'
import warnings
warnings.filterwarnings('ignore')
from tensorflow.python.util import deprecation
deprecation._PRINT_DEPRECATION_WARNINGS = False

Keras

Kami menggunakan pustaka Keras untuk mengimpor kumpulan data. Kami akan menggunakanmnistset data untuk digit tulisan tangan. Kami mengimpor paket yang diperlukan menggunakan pernyataan berikut

from keras.datasets import mnist

Kami akan menentukan jaringan saraf pembelajaran dalam kami menggunakan paket Keras. Kami mengimpor fileSequential, Dense, Dropout dan Activationpaket untuk mendefinisikan arsitektur jaringan. Kita gunakanload_modelpaket untuk menyimpan dan mengambil model kami. Kami juga menggunakannp_utilsuntuk beberapa utilitas yang kami butuhkan dalam proyek kami. Impor ini dilakukan dengan pernyataan program berikut -

from keras.models import Sequential, load_model
from keras.layers.core import Dense, Dropout, Activation
from keras.utils import np_utils

Ketika Anda menjalankan kode ini, Anda akan melihat pesan di konsol yang mengatakan bahwa Keras menggunakan TensorFlow di backend. Tangkapan layar pada tahap ini ditampilkan di sini -

Sekarang, karena kami memiliki semua impor yang diperlukan oleh proyek kami, kami akan melanjutkan untuk menentukan arsitektur jaringan Deep Learning kami.

Model jaringan saraf kami akan terdiri dari tumpukan lapisan linier. Untuk mendefinisikan model seperti itu, kami memanggilSequential fungsi -

model = Sequential()

Lapisan Input

Kami mendefinisikan lapisan input, yang merupakan lapisan pertama di jaringan kami menggunakan pernyataan program berikut -

model.add(Dense(512, input_shape=(784,)))

Ini menciptakan lapisan dengan 512 node (neuron) dengan 784 node input. Ini digambarkan pada gambar di bawah ini -

Perhatikan bahwa semua node input terhubung sepenuhnya ke Layer 1, yaitu setiap node input terhubung ke semua 512 node dari Layer 1.

Selanjutnya, kita perlu menambahkan fungsi aktivasi untuk output Layer 1. Kita akan menggunakan ULT sebagai aktivasi kita. Fungsi aktivasi ditambahkan menggunakan pernyataan program berikut -

model.add(Activation('relu'))

Selanjutnya, kami menambahkan Dropout 20% menggunakan pernyataan di bawah ini. Dropout adalah teknik yang digunakan untuk mencegah model overfitting.

model.add(Dropout(0.2))

Pada titik ini, lapisan masukan kami sepenuhnya ditentukan. Selanjutnya, kami akan menambahkan lapisan tersembunyi.

Lapisan Tersembunyi

Lapisan tersembunyi kami akan terdiri dari 512 node. Masukan ke lapisan tersembunyi berasal dari lapisan masukan yang telah ditetapkan sebelumnya. Semua node terhubung sepenuhnya seperti pada kasus sebelumnya. Output dari lapisan tersembunyi akan menuju ke lapisan berikutnya dalam jaringan, yang akan menjadi lapisan akhir dan keluaran kami. Kami akan menggunakan aktivasi ULT yang sama seperti untuk lapisan sebelumnya dan putus sekolah sebesar 20%. Kode untuk menambahkan lapisan ini diberikan di sini -

model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2))

Jaringan pada tahap ini dapat divisualisasikan sebagai berikut -

Selanjutnya, kami akan menambahkan lapisan terakhir ke jaringan kami, yang merupakan lapisan keluaran. Perhatikan bahwa Anda dapat menambahkan sejumlah lapisan tersembunyi menggunakan kode yang mirip dengan yang Anda gunakan di sini. Menambahkan lebih banyak lapisan akan membuat jaringan menjadi rumit untuk pelatihan; namun, memberikan keuntungan yang pasti dari hasil yang lebih baik dalam banyak kasus meskipun tidak semua.

Lapisan Keluaran

Lapisan keluaran hanya terdiri dari 10 node karena kami ingin mengklasifikasikan gambar yang diberikan dalam 10 digit berbeda. Kami menambahkan lapisan ini, menggunakan pernyataan berikut -

model.add(Dense(10))

Karena kami ingin mengklasifikasikan output dalam 10 unit berbeda, kami menggunakan aktivasi softmax. Dalam kasus ULT, hasilnya adalah biner. Kami menambahkan aktivasi menggunakan pernyataan berikut -

model.add(Activation('softmax'))

Pada titik ini, jaringan kami dapat divisualisasikan seperti yang ditunjukkan pada diagram di bawah ini -

Pada titik ini, model jaringan kami sepenuhnya ditentukan dalam perangkat lunak. Jalankan sel kode dan jika tidak ada kesalahan, Anda akan mendapatkan pesan konfirmasi di layar seperti yang ditunjukkan pada gambar di bawah -

Selanjutnya, kita perlu mengkompilasi modelnya.

Kompilasi dilakukan menggunakan satu panggilan metode tunggal yang dipanggil compile.

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

Itu compileMetode membutuhkan beberapa parameter. Parameter kerugian ditentukan memiliki tipe'categorical_crossentropy'. Parameter metrik disetel ke'accuracy' dan akhirnya kami menggunakan adampengoptimal untuk melatih jaringan. Output pada tahap ini ditunjukkan di bawah ini -

Sekarang, kami siap untuk memasukkan data ke jaringan kami.

Memuat Data

Seperti yang dikatakan sebelumnya, kami akan menggunakan file mnistset data disediakan oleh Keras. Saat kami memuat data ke sistem kami, kami akan membaginya dalam data pelatihan dan pengujian. Data dimuat dengan memanggilload_data metode sebagai berikut -

(X_train, y_train), (X_test, y_test) = mnist.load_data()

Output pada tahap ini terlihat seperti berikut -

Sekarang, kita akan mempelajari struktur dataset yang dimuat.

Data yang diberikan kepada kami adalah gambar grafik berukuran 28 x 28 piksel, masing-masing berisi satu digit antara 0 dan 9. Kami akan menampilkan sepuluh gambar pertama di konsol. Kode untuk melakukannya diberikan di bawah ini -

# printing first 10 images
for i in range(10):

plot.subplot(3,5,i+1)
plot.tight_layout()
plot.imshow(X_train[i], cmap='gray', interpolation='none')
plot.title("Digit: {}".format(y_train[i]))
plot.xticks([])
plot.yticks([])

Dalam loop iteratif 10 hitungan, kami membuat subplot pada setiap iterasi dan menampilkan gambar dari X_trainvektor di dalamnya. Kami memberi judul setiap gambar dari yang sesuaiy_trainvektor. Perhatikan bahway_train vektor berisi nilai sebenarnya untuk gambar terkait di X_trainvektor. Kami menghapus tanda sumbu x dan y dengan memanggil dua metodexticks dan yticksdengan argumen nol. Saat Anda menjalankan kode, Anda akan melihat output berikut -

Selanjutnya, kami akan menyiapkan data untuk dimasukkan ke dalam jaringan kami.

Sebelum kami memasukkan data ke jaringan kami, itu harus diubah ke dalam format yang dibutuhkan oleh jaringan. Ini disebut menyiapkan data untuk jaringan. Ini umumnya terdiri dari mengubah input multi-dimensi menjadi vektor satu dimensi dan menormalkan titik data.

Pembentukan Ulang Vektor Input

Gambar dalam dataset kami terdiri dari 28 x 28 piksel. Ini harus diubah menjadi vektor berdimensi tunggal dengan ukuran 28 * 28 = 784 untuk dimasukkan ke dalam jaringan kita. Kami melakukannya dengan memanggilreshape metode pada vektor.

X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)

Sekarang, vektor pelatihan kita akan terdiri dari 60.000 titik data, masing-masing terdiri dari vektor berdimensi tunggal berukuran 784. Demikian pula, vektor uji kita akan terdiri dari 10.000 titik data vektor berdimensi tunggal berukuran 784.

Normalisasi Data

Data yang berisi vektor input saat ini memiliki nilai diskrit antara 0 dan 255 - level skala abu-abu. Menormalkan nilai piksel ini antara 0 dan 1 membantu mempercepat pelatihan. Karena kita akan menggunakan penurunan gradien stokastik, menormalkan data juga akan membantu mengurangi kemungkinan macet di optima lokal.

Untuk menormalkan data, kami merepresentasikannya sebagai tipe float dan membaginya dengan 255 seperti yang ditunjukkan pada potongan kode berikut -

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Sekarang mari kita lihat bagaimana tampilan data yang dinormalisasi.

Memeriksa Data Normalisasi

Untuk melihat data yang dinormalisasi, kami akan memanggil fungsi histogram seperti yang ditunjukkan di sini -

plot.hist(X_train[0])
plot.title("Digit: {}".format(y_train[0]))

Di sini, kami memplot histogram dari elemen pertama X_trainvektor. Kami juga mencetak digit yang diwakili oleh titik data ini. Output dari menjalankan kode di atas ditampilkan di sini -

Anda akan melihat kepadatan titik-titik yang memiliki nilai mendekati nol. Ini adalah titik titik hitam pada gambar, yang jelas merupakan bagian utama gambar. Titik skala abu-abu lainnya, yang mendekati warna putih, mewakili digit. Anda dapat memeriksa distribusi piksel untuk digit lain. Kode di bawah ini mencetak histogram digit pada indeks 2 dalam dataset pelatihan.

plot.hist(X_train[2])
plot.title("Digit: {}".format(y_train[2])

Output dari menjalankan kode di atas ditunjukkan di bawah ini -

Dengan membandingkan dua gambar di atas, Anda akan melihat bahwa distribusi piksel putih dalam dua gambar berbeda yang menunjukkan representasi digit yang berbeda - "5" dan "4" pada dua gambar di atas.

Selanjutnya, kami akan memeriksa distribusi data dalam kumpulan data pelatihan lengkap kami.

Memeriksa Distribusi Data

Sebelum kami melatih model pembelajaran mesin kami pada kumpulan data kami, kami harus mengetahui distribusi angka unik dalam kumpulan data kami. Gambar kami mewakili 10 digit berbeda mulai dari 0 hingga 9. Kami ingin mengetahui jumlah digit 0, 1, dll., Dalam dataset kami. Kami bisa mendapatkan informasi ini dengan menggunakanunique metode Numpy.

Gunakan perintah berikut untuk mencetak jumlah nilai unik dan jumlah kemunculan masing-masing

print(np.unique(y_train, return_counts=True))

Saat Anda menjalankan perintah di atas, Anda akan melihat output berikut -

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]))

Ini menunjukkan bahwa ada 10 nilai yang berbeda - 0 sampai 9. Ada 5923 kemunculan digit 0, 6742 kemunculan digit 1, dan seterusnya. Tangkapan layar keluaran ditampilkan di sini -

Sebagai langkah terakhir dalam persiapan data, kita perlu menyandikan data kita.

Pengkodean Data

Kami memiliki sepuluh kategori dalam kumpulan data kami. Dengan demikian, kami akan menyandikan keluaran kami dalam sepuluh kategori ini menggunakan penyandian satu hot. Kami menggunakan metode to_categorial dari utilitas Numpy untuk melakukan pengkodean. Setelah data keluaran dikodekan, setiap titik data akan diubah menjadi vektor berdimensi tunggal berukuran 10. Sebagai contoh, digit 5 sekarang akan direpresentasikan sebagai [0,0,0,0,0,1,0,0,0 , 0].

Encode data menggunakan potongan kode berikut -

n_classes = 10
Y_train = np_utils.to_categorical(y_train, n_classes)

Anda dapat memeriksa hasil encoding dengan mencetak 5 elemen pertama dari vektor Y_train yang dikategorikan.

Gunakan kode berikut untuk mencetak 5 vektor pertama -

for i in range(5):
   print (Y_train[i])

Anda akan melihat output berikut -

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]

Elemen pertama mewakili angka 5, elemen kedua mewakili angka 0, dan seterusnya.

Terakhir, Anda juga harus mengkategorikan data pengujian, yang dilakukan menggunakan pernyataan berikut -

Y_test = np_utils.to_categorical(y_test, n_classes)

Pada tahap ini, data Anda sepenuhnya siap untuk dimasukkan ke dalam jaringan.

Selanjutnya, datanglah bagian terpenting dan itu adalah melatih model jaringan kita.

Pelatihan model dilakukan dalam satu panggilan metode yang disebut fit yang mengambil beberapa parameter seperti yang terlihat pada kode di bawah ini -

history = model.fit(X_train, Y_train,
   batch_size=128, epochs=20,
   verbose=2,
   validation_data=(X_test, Y_test)))

Dua parameter pertama untuk metode fit menentukan fitur dan keluaran dari set data pelatihan.

Itu epochsdiatur ke 20; kami berasumsi bahwa pelatihan akan berkumpul dalam maksimal 20 epoch - iterasi. Model yang dilatih divalidasi pada data pengujian seperti yang ditentukan di parameter terakhir.

Output parsial dari menjalankan perintah di atas ditampilkan di sini -

Train on 60000 samples, validate on 10000 samples
Epoch 1/20
- 9s - loss: 0.2488 - acc: 0.9252 - val_loss: 0.1059 - val_acc: 0.9665
Epoch 2/20
- 9s - loss: 0.1004 - acc: 0.9688 - val_loss: 0.0850 - val_acc: 0.9715
Epoch 3/20
- 9s - loss: 0.0723 - acc: 0.9773 - val_loss: 0.0717 - val_acc: 0.9765
Epoch 4/20
- 9s - loss: 0.0532 - acc: 0.9826 - val_loss: 0.0665 - val_acc: 0.9795
Epoch 5/20
- 9s - loss: 0.0457 - acc: 0.9856 - val_loss: 0.0695 - val_acc: 0.9792

Tangkapan layar keluaran diberikan di bawah ini untuk referensi cepat Anda -

Sekarang, saat model dilatih pada data pelatihan kami, kami akan mengevaluasi performanya.

Untuk mengevaluasi kinerja model, kami menyebutnya evaluate metode sebagai berikut -

loss_and_metrics = model.evaluate(X_test, Y_test, verbose=2)

Untuk mengevaluasi kinerja model, kami menyebutnya evaluate metode sebagai berikut -

loss_and_metrics = model.evaluate(X_test, Y_test, verbose=2)

Kami akan mencetak kerugian dan akurasi menggunakan dua pernyataan berikut -

print("Test Loss", loss_and_metrics[0])
print("Test Accuracy", loss_and_metrics[1])

Ketika Anda menjalankan pernyataan di atas, Anda akan melihat output berikut -

Test Loss 0.08041584826191042
Test Accuracy 0.9837

Ini menunjukkan akurasi tes 98%, yang seharusnya dapat kami terima. Apa artinya bagi kami bahwa dalam 2% kasus, angka tulisan tangan tidak akan diklasifikasikan dengan benar. Kami juga akan memplot metrik akurasi dan kerugian untuk melihat bagaimana performa model pada data pengujian.

Merencanakan Metrik Akurasi

Kami menggunakan rekaman historyselama pelatihan kami untuk mendapatkan plot metrik akurasi. Kode berikut akan memetakan akurasi pada setiap epoch. Kami mengambil akurasi data pelatihan ("acc") dan akurasi data validasi ("val_acc") untuk pembuatan plot.

plot.subplot(2,1,1)
plot.plot(history.history['acc'])
plot.plot(history.history['val_acc'])
plot.title('model accuracy')
plot.ylabel('accuracy')
plot.xlabel('epoch')
plot.legend(['train', 'test'], loc='lower right')

Plot output ditunjukkan di bawah ini -

Seperti yang Anda lihat di diagram, akurasi meningkat dengan cepat dalam dua periode pertama, menunjukkan bahwa jaringan belajar dengan cepat. Setelah itu, kurva mendatar yang menunjukkan bahwa tidak terlalu banyak masa yang diperlukan untuk melatih model lebih lanjut. Umumnya, jika akurasi data pelatihan ("acc") terus meningkat sementara akurasi data validasi ("val_acc") semakin buruk, Anda akan mengalami overfitting. Ini menunjukkan bahwa model mulai menghafal data.

Kami juga akan memplot metrik kerugian untuk memeriksa kinerja model kami.

Merencanakan Metrik Kerugian

Sekali lagi, kami memplot kerugian pada data pelatihan ("kerugian") dan pengujian ("val_loss"). Ini dilakukan dengan menggunakan kode berikut -

plot.subplot(2,1,2)
plot.plot(history.history['loss'])
plot.plot(history.history['val_loss'])
plot.title('model loss')
plot.ylabel('loss')
plot.xlabel('epoch')
plot.legend(['train', 'test'], loc='upper right')

Output dari kode ini ditunjukkan di bawah ini -

Seperti yang Anda lihat di diagram, kerugian pada set pelatihan berkurang dengan cepat untuk dua periode pertama. Untuk set pengujian, kerugian tidak berkurang pada tingkat yang sama seperti set pelatihan, tetapi tetap hampir datar untuk beberapa epoch. Ini berarti model kami menggeneralisasi dengan baik ke data yang tidak terlihat.

Sekarang, kami akan menggunakan model terlatih kami untuk memprediksi digit dalam data pengujian kami.

Untuk memprediksi angka dalam suatu data ghaib sangatlah mudah. Anda hanya perlu memanggilpredict_classes metode dari model dengan meneruskannya ke vektor yang terdiri dari titik data Anda yang tidak diketahui.

predictions = model.predict_classes(X_test)

Panggilan metode mengembalikan prediksi dalam vektor yang dapat diuji untuk 0 dan 1 terhadap nilai sebenarnya. Ini dilakukan dengan menggunakan dua pernyataan berikut -

correct_predictions = np.nonzero(predictions == y_test)[0]
incorrect_predictions = np.nonzero(predictions != y_test)[0]

Akhirnya, kami akan mencetak jumlah prediksi yang benar dan salah menggunakan dua pernyataan program berikut -

print(len(correct_predictions)," classified correctly")
print(len(incorrect_predictions)," classified incorrectly")

Saat Anda menjalankan kode, Anda akan mendapatkan output berikut -

9837 classified correctly
163 classified incorrectly

Sekarang, karena Anda telah melatih model dengan memuaskan, kami akan menyimpannya untuk digunakan di masa mendatang.

Kami akan menyimpan model yang dilatih di drive lokal kami di folder model di direktori kerja kami saat ini. Untuk menyimpan model, jalankan kode berikut -

directory = "./models/"
name = 'handwrittendigitrecognition.h5'
path = os.path.join(save_dir, name)
model.save(path)
print('Saved trained model at %s ' % path)

Output setelah menjalankan kode ditunjukkan di bawah ini -

Sekarang, karena Anda telah menyimpan model terlatih, Anda dapat menggunakannya nanti untuk memproses data Anda yang tidak dikenal.

Untuk memprediksi data yang tidak terlihat, Anda harus memuat model yang dilatih ke dalam memori terlebih dahulu. Ini dilakukan dengan menggunakan perintah berikut -

model = load_model ('./models/handwrittendigitrecognition.h5')

Perhatikan bahwa kami hanya memuat file .h5 ke dalam memori. Ini menyiapkan seluruh jaringan neural dalam memori bersama dengan bobot yang ditetapkan ke setiap lapisan.

Sekarang, untuk melakukan prediksi Anda pada data yang tidak terlihat, muat data, biarkan menjadi satu atau lebih item, ke dalam memori. Proses data terlebih dahulu untuk memenuhi persyaratan masukan model kami seperti yang Anda lakukan pada data pelatihan dan pengujian di atas. Setelah preprocessing, masukkan ke jaringan Anda. Model akan mengeluarkan prediksinya.

Keras menyediakan API tingkat tinggi untuk membuat jaringan neural dalam. Dalam tutorial ini, Anda belajar membuat jaringan neural dalam yang dilatih untuk menemukan digit dalam teks tulisan tangan. Jaringan multi-layer dibuat untuk tujuan ini. Keras memungkinkan Anda untuk menentukan fungsi aktivasi pilihan Anda di setiap lapisan. Dengan menggunakan penurunan gradien, jaringan dilatih pada data pelatihan. Keakuratan jaringan yang terlatih dalam memprediksi data yang tidak terlihat diuji pada data pengujian. Anda belajar merencanakan metrik akurasi dan kesalahan. Setelah jaringan sepenuhnya terlatih, Anda menyimpan model jaringan untuk digunakan di masa mendatang.