Tutorial Keras: Apa itu Keras? Cara Memasang di Python [Contoh]

Apa itu Keras?

Keras adalah perpustakaan Jaringan Syaraf Sumber Terbuka yang tertulis Python yang berjalan di atas Theano atau Tensorflow. Ini dirancang agar modular, cepat dan mudah digunakan. Ini dikembangkan oleh François Chollet, seorang insinyur Google. Keras tidak menangani komputasi tingkat rendah. Sebaliknya, ia menggunakan perpustakaan lain untuk melakukannya, yang disebut “Backend.

Keras adalah pembungkus API tingkat tinggi untuk API tingkat rendah, yang mampu berjalan di atas TensorFlow, CNTK, atau Theano. Keras High-Level API menangani cara kita membuat model, mendefinisikan lapisan, atau menyiapkan beberapa model input-output. Pada level ini, Keras juga mengkompilasi model kita dengan fungsi loss dan optimizer, proses pelatihan dengan fungsi fit. Keras masuk Python tidak menangani API Tingkat Rendah seperti pembuatan grafik komputasi, pembuatan tensor atau variabel lainnya karena sudah ditangani oleh mesin “backend”.

Apa itu Backend?

Backend adalah istilah dalam Keras yang melakukan semua komputasi tingkat rendah seperti produk tensor, konvolusi, dan banyak hal lainnya dengan bantuan perpustakaan lain seperti Tensorflow atau Theano. Jadi, “mesin backend” akan melakukan komputasi dan pengembangan model. Tensorflow adalah “mesin backend” default tetapi kita dapat mengubahnya dalam konfigurasi.

Theano, Tensorflow, dan CNTK Backend

Theano adalah proyek open source yang dikembangkan oleh kelompok MILA di Universitas Montreal, Quebec, Kanada. Ini adalah Framework pertama yang banyak digunakan. Ini adalah sebuah Python pustaka yang membantu dalam array multidimensi untuk operasi matematika menggunakan Numpy atau Scipy. Theano dapat menggunakan GPU untuk komputasi yang lebih cepat, ia juga dapat secara otomatis membuat grafik simbolik untuk menghitung gradien. Di situs webnya, Theano mengklaim bahwa ia dapat mengenali ekspresi numerik yang tidak stabil dan menghitungnya dengan algoritma yang lebih stabil, ini sangat berguna untuk ekspresi kita yang tidak stabil.

Di sisi lain, Tensorflow adalah bintang baru dalam kerangka pembelajaran mendalam. Dikembangkan oleh tim Brain Google, ini adalah alat pembelajaran mendalam yang paling populer. Dengan banyak fitur, dan peneliti berkontribusi membantu mengembangkan kerangka ini untuk tujuan pembelajaran mendalam.

Mesin backend lain untuk Keras adalah The Microsoft Perangkat Kognitif atau CNTK. Ini adalah kerangka pembelajaran mendalam sumber terbuka yang dikembangkan oleh Microsoft Tim. Ini dapat berjalan pada multi GPU atau multi-mesin untuk melatih model pembelajaran mendalam dalam skala besar. Dalam beberapa kasus, CNTK dilaporkan lebih cepat dibandingkan framework lain seperti Tensorflow atau Theano. Selanjutnya dalam tutorial Keras CNN ini, kita akan membandingkan backend Theano, TensorFlow, dan CNTK.

Membandingkan Backend

Kita perlu melakukan benchmark untuk mengetahui perbandingan kedua backend ini. Seperti yang Anda lihat di Patokan Jeong-Yoon Lee, kinerja 3 backend berbeda pada perangkat keras berbeda dibandingkan. Dan hasilnya adalah Theano lebih lambat dibandingkan backend lainnya, dilaporkan 50 kali lebih lambat, tetapi akurasinya mendekati satu sama lain.

Lain tes benchmark dilakukan oleh Jasmeet Bhatia. Dia melaporkan bahwa Theano lebih lambat dari Tensorflow untuk beberapa pengujian. Namun akurasi keseluruhan hampir sama untuk setiap jaringan yang diuji.

Jadi, antara Theano, Tensorflow, dan CTK, terlihat jelas bahwa TensorFlow lebih baik daripada Theano. Dengan TensorFlow, waktu komputasi jauh lebih singkat dan CNN lebih baik dibandingkan yang lain.

Selanjutnya di Keras ini Python tutorialnya, kita akan belajar tentang perbedaan Keras dan TensorFlow (Keras vs Tensorflow).

Keras vs Tensorflow

Parameters	Keras	aliran tensor
Tipe	Pembungkus API Tingkat Tinggi	API Tingkat Rendah
Kompleksitas	Mudah digunakan jika Anda Python bahasa	Anda perlu mempelajari sintaks penggunaan beberapa fungsi Tensorflow
Tujuan	Penerapan cepat untuk membuat model dengan lapisan standar	Memungkinkan Anda membuat grafik komputasi atau lapisan model yang sewenang-wenang
Tools	Menggunakan alat debug API lainnya seperti TFDBG	Anda dapat menggunakan alat visualisasi Tensorboard
Komunitas	Komunitas aktif yang besar	Komunitas besar yang aktif dan sumber daya yang dibagikan secara luas

Keunggulan Keras

Penerapan Cepat dan Mudah dimengerti

Keras sangat cepat membuat model jaringan. Jika Anda ingin membuat model jaringan sederhana dengan beberapa baris, Python Keras dapat membantu Anda dalam hal itu. Lihatlah contoh Keras di bawah ini:

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

Karena API-nya ramah, kita dapat dengan mudah memahami prosesnya. Menulis kode dengan fungsi sederhana dan tidak perlu mengatur banyak parameter.

Dukungan Komunitas Besar

Ada banyak komunitas AI yang menggunakan Keras untuk kerangka Deep Learning mereka. Banyak dari mereka juga mempublikasikan kode mereka dan tutorialnya kepada masyarakat umum.

Memiliki banyak Backend

Anda dapat memilih Tensorflow, CNTK, dan Theano sebagai backend Anda dengan Keras. Anda dapat memilih backend berbeda untuk proyek berbeda bergantung pada kebutuhan Anda. Setiap backend memiliki keunggulan uniknya masing-masing.

Penerapan Model Lintas Platform dan Mudah

Dengan berbagai perangkat dan platform yang didukung, Anda dapat menerapkan Keras di perangkat apa pun

• iOS dengan CoreML
• Android dengan Tensorflow Android,
• Browser web dengan dukungan .js
• Mesin awan
• raspberry Pi

Dukungan Multi GPU

Anda dapat melatih Keras pada satu GPU atau menggunakan beberapa GPU sekaligus. Karena Keras memiliki dukungan bawaan untuk paralelisme data sehingga dapat memproses data dalam jumlah besar dan mempercepat waktu yang dibutuhkan untuk melatihnya.

Kekurangan Keras

Tidak dapat menangani API tingkat rendah

Keras hanya menangani API tingkat tinggi yang berjalan di atas kerangka kerja atau mesin backend lain seperti Tensorflow, Theano, atau CNTK. Jadi tidak terlalu berguna jika Anda ingin membuat layer abstrak sendiri untuk keperluan penelitian karena Keras sudah memiliki lapisan yang sudah dikonfigurasi sebelumnya.

Menginstal Keras

Di bagian ini, kita akan melihat berbagai metode yang tersedia untuk menginstal Keras

Instal langsung atau Lingkungan Virtual

Mana yang lebih baik? Instal langsung ke python saat ini atau gunakan lingkungan virtual? Saya sarankan menggunakan lingkungan virtual jika Anda memiliki banyak proyek. Ingin tahu alasannya? Ini karena proyek yang berbeda mungkin menggunakan versi perpustakaan keras yang berbeda.

Misalnya, saya punya proyek yang perlu Python 3.5 menggunakan OpenCV 3.3 dengan backend Keras-Theano yang lebih lama tetapi di proyek lain saya harus menggunakan Keras dengan versi terbaru dan Tensorflow sebagai backendnya Python Dukungan 3.6.6

Kami tidak ingin perpustakaan Keras saling bertentangan, bukan? Jadi kami menggunakan Lingkungan Virtual untuk melokalisasi proyek dengan jenis perpustakaan tertentu atau kami dapat menggunakan platform lain seperti Layanan Cloud untuk melakukan komputasi untuk kami seperti Amazon Layanan web.

Menginstal Keras aktif Amazon Layanan Web (AWS)

Amazon Web Service adalah platform yang menawarkan layanan dan produk Cloud Computing untuk peneliti atau tujuan lainnya. AWS menyewakan perangkat keras, jaringan, Database, dll sehingga kami dapat menggunakannya langsung dari internet. Salah satu layanan AWS yang populer untuk tujuan pembelajaran mendalam adalah Amazon Layanan Pembelajaran Mendalam Gambar Mesin atau DL

Untuk instruksi mendetail tentang cara menggunakan AWS, lihat ini tutorial

Catatan pada AMI: Anda akan memiliki AMI berikut yang tersedia

AWS Deep Learning AMI adalah lingkungan virtual di Layanan AWS EC2 yang membantu peneliti atau praktisi untuk bekerja dengan Deep Learning. DLAMI menawarkan mulai dari mesin CPU kecil hingga mesin multi GPU bertenaga tinggi dengan CUDA, cuDNN yang telah dikonfigurasi sebelumnya, dan dilengkapi dengan berbagai kerangka pembelajaran mendalam.

Jika Anda ingin menggunakannya secara instan, Anda harus memilih Deep Learning AMI karena sudah diinstal sebelumnya dengan kerangka pembelajaran mendalam yang populer.

Namun jika Anda ingin mencoba kerangka pembelajaran mendalam khusus untuk penelitian, Anda harus menginstal AMI Basis Pembelajaran Mendalam karena ia dilengkapi dengan pustaka dasar seperti CUDA, cuDNN, driver GPU, dan pustaka lain yang diperlukan untuk dijalankan dengan lingkungan pembelajaran mendalam Anda.

Cara Memasang Keras di Amazon SageMaker

Amazon SageMaker adalah platform pembelajaran mendalam untuk membantu Anda melatih dan menerapkan jaringan pembelajaran mendalam dengan algoritma terbaik.

Sebagai seorang pemula, ini adalah metode termudah untuk menggunakan Keras. Di bawah ini adalah proses cara menginstal Keras Amazon Pembuat Sage:

Langkah 1) Buka Amazon SageMaker

Pada langkah pertama, Buka Amazon Pembuat Sagem konsol dan klik Buat instance notebook.

Langkah 2) Masukkan detailnya

1. Masukkan nama buku catatan Anda.
2. Buat peran IAM. Ini akan membuat peran AMI Amazon Peran IAM dalam format AmazonSageMaker-Peran Eksekusi-YYYYMMDD|HHmmSS.
3. Terakhir, pilih Buat instans buku catatan. Setelah beberapa saat, Amazon Sagemaker meluncurkan contoh notebook.

Note: Jika Anda ingin mengakses sumber daya dari VPC Anda, tetapkan akses internet langsung sebagai diaktifkan. Jika tidak, instans notebook ini tidak akan memiliki akses internet, sehingga tidak mungkin untuk melatih atau menghosting model.

Langkah 3) Luncurkan instance

Klik Buka untuk meluncurkan instance

Langkah 4) Mulai coding

In Jupyter, Klik Baru> conda_tensorflow_p36 dan Anda siap membuat kode

Instal Keras di Linux

Untuk mengaktifkan Keras dengan Tensorflow sebagai mesin backendnya, kita perlu menginstal Tensorflow terlebih dahulu. Jalankan perintah ini untuk menginstal tensorflow dengan CPU (tanpa GPU)

pip install --upgrade tensorflow

jika Anda ingin mengaktifkan dukungan GPU untuk tensorflow Anda dapat menggunakan perintah ini

pip install --upgrade tensorflow-gpu

mari kita check in Python untuk melihat apakah instalasi kita berhasil dengan mengetik

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

jika tidak ada pesan error maka proses instalasi berhasil

Instal Keras

Setelah kita menginstal Tensorflow, mari mulai menginstal keras. Ketik perintah ini di terminal

pip install keras

itu akan mulai menginstal Keras dan juga semua dependensinya. Anda akan melihat sesuatu seperti ini:

Sekarang kami telah menginstal Keras di sistem kami!

Verifikasi

Sebelum kita mulai menggunakan Keras, kita harus memeriksa apakah Keras kita menggunakan Tensorflow sebagai backend dengan membuka file konfigurasi:

gedit ~/.keras/keras.json

Anda akan melihat sesuatu seperti ini

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

seperti yang Anda lihat, "backend" menggunakan tensorflow. Artinya keras menggunakan Tensorflow sebagai backendnya seperti yang kita harapkan

dan sekarang jalankan di terminal dengan mengetik

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>> 

Cara Memasang Keras di Windows

Sebelum kita menginstal aliran tensor dan Keras, kita harus menginstal Python, pip, dan virtualenv. Jika Anda sudah menginstal pustaka ini, Anda harus melanjutkan ke langkah berikutnya, jika tidak, lakukan hal berikut:

Install Python 3 dengan mengunduh dari ini link

Instal pip dengan menjalankan ini

Instal virtualenv dengan perintah ini

pip3 install –U pip virtualenv

Install Microsoft visual C++ Pembaruan 2015 yang Dapat Didistribusikan Ulang 3

• Kunjungi situs unduhan Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Pilih Dapat Didistribusikan Ulang dan Alat Bangun
• Men-download dan menginstal Microsoft visual C++ Pembaruan 2015 yang Dapat Didistribusikan Ulang 3

Kemudian jalankan skrip ini

pip3 install virtualenv

Siapkan Lingkungan Virtual

Ini digunakan untuk mengisolasi sistem kerja dengan sistem utama.

virtualenv –-system-site-packages –p python3 ./venv

Aktifkan lingkungan

.\venv\Scripts\activate

Setelah menyiapkan lingkungan, instalasi Tensorflow dan Keras tetap sama seperti Linux. Selanjutnya dalam tutorial Pembelajaran Mendalam dengan Keras ini, kita akan belajar tentang dasar-dasar Keras untuk Pembelajaran Mendalam.

Dasar-dasar Keras untuk Pembelajaran Mendalam

Struktur utama di Keras adalah Model yang mendefinisikan grafik lengkap suatu jaringan. Anda dapat menambahkan lebih banyak lapisan ke model yang sudah ada untuk membangun model kustom yang Anda perlukan untuk proyek Anda.

Berikut cara membuat Model Sequential dan beberapa lapisan yang umum digunakan dalam deep learning

1. Model Berurutan

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. Lapisan Konvolusi

Ini adalah Keras Python contoh convolutional layer sebagai input layer dengan bentuk input 320x320x3, dengan 48 filter ukuran 3×3 dan menggunakan ReLU sebagai fungsi aktivasi.

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

tipe lainnya adalah

model.add(Conv2D(48, (3, 3), activation='relu'))

3. MaksPooling Lapisan

Untuk menurunkan sampel representasi input, gunakan MaxPool2d dan tentukan ukuran kernel

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

4. Lapisan Padat

menambahkan Lapisan Terhubung Sepenuhnya hanya dengan menentukan Ukuran keluaran

model.add(Dense(256, activation='relu'))

5. Lapisan Putus Sekolah

Menambahkan lapisan putus sekolah dengan probabilitas 50%.

model.add(Dropout(0.5))

Menyusun, Melatih, dan Mengevaluasi

Setelah kita mendefinisikan model kita, mari kita mulai melatihnya. Diperlukan kompilasi jaringan terlebih dahulu dengan fungsi loss dan fungsi optimizer. Hal ini akan memungkinkan jaringan untuk mengubah bobot dan meminimalkan kerugian.

model.compile(loss='mean_squared_error', optimizer='adam')

Sekarang untuk memulai pelatihan, gunakan fit untuk memasukkan data pelatihan dan validasi ke model. Ini akan memungkinkan Anda untuk melatih jaringan dalam batch dan mengatur waktu.

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

Langkah terakhir kita adalah mengevaluasi model dengan data pengujian.

score = model.evaluate(x_test, y_test, batch_size=32)

Mari kita coba menggunakan regresi linier sederhana

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

Setelah data dilatih, outputnya akan terlihat seperti ini

dengan berat awalnya

Linear regression model is initialized with weights w: 0.37, b: 0.00

dan berat akhir

Linear regression model is trained to have weight w: 3.70, b: 0.61

Sempurnakan Model Terlatih di Keras dan Cara Menggunakannya

Mengapa kami menggunakan Model Fine Tune dan kapan kami menggunakannya

Penyempurnaan adalah tugas untuk mengubah model yang telah dilatih sebelumnya sehingga parameternya dapat beradaptasi dengan model baru. Saat kita ingin melatih model baru dari awal, kita memerlukan data dalam jumlah besar, agar jaringan dapat menemukan semua parameter. Namun dalam kasus ini, kami akan menggunakan model terlatih sehingga parameternya sudah dipelajari dan memiliki bobot.

Misalnya, jika kita ingin melatih model Keras kita sendiri untuk menyelesaikan masalah klasifikasi tetapi kita hanya memiliki sedikit data, maka kita dapat menyelesaikannya dengan menggunakan a Transfer Belajar + Metode Penyempurnaan.

Dengan menggunakan jaringan & bobot yang telah dilatih sebelumnya, kita tidak perlu melatih seluruh jaringan. Kita hanya perlu melatih lapisan terakhir yang digunakan untuk menyelesaikan tugas kita yang kita sebut metode Fine-Tuning.

Persiapan Model Jaringan

Untuk model yang telah dilatih sebelumnya, kita dapat memuat berbagai model yang sudah dimiliki Keras di perpustakaannya seperti:

• VGG16
• AwalV3
• ResNet
• Jaringan Seluler
• *ception
• AwalResNetV2

Namun dalam proses ini, kami akan menggunakan model jaringan VGG16 dan imageNet sebagai bobot model kami. Kami akan menyempurnakan jaringan untuk mengklasifikasikan 8 jenis kelas berbeda menggunakan Gambar dari Kumpulan Data Gambar Alami Kaggle

Arsitektur model VGG16

sumber

Mengunggah Data Kami ke AWS S3 Bucket

Untuk proses latihannya kita akan menggunakan gambar gambar alam dari 8 kelas yang berbeda seperti pesawat terbang, mobil, kucing, anjing, bunga, buah, sepeda motor, dan orang. Pertama, kita perlu mengunggah data kita ke Amazon ember S3.

Amazon Ember S3

Langkah 1) Setelah login ke akun S3 Anda, mari buat bucket dengan clocking Buat Bucket

Langkah 2) Sekarang pilih Nama Bucket dan Wilayah Anda sesuai dengan akun Anda. Pastikan nama bucket tersedia. Setelah itu klik Buat.

Langkah 3) Seperti yang Anda lihat, Bucket Anda siap digunakan. Namun seperti yang Anda lihat, Aksesnya Bukan untuk publik, ada baiknya Anda jika ingin merahasiakannya untuk Anda sendiri. Anda dapat mengubah bucket ini untuk Akses Publik di Properti Bucket

Langkah 4) Sekarang Anda mulai mengunggah data pelatihan Anda ke Bucket Anda. Disini saya akan mengupload file tar.gz yang berisi gambar untuk proses pelatihan dan pengujian.

Langkah 5) Sekarang klik pada file Anda dan salin Link agar kita bisa mendownloadnya.

Persiapan data

Kita perlu menghasilkan data pelatihan menggunakan Keras ImageDataGenerator.

Pertama, Anda harus mengunduh menggunakan wget dengan tautan ke file Anda dari S3 Bucket.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

Setelah Anda mengunduh data, mari kita mulai Proses Pelatihan.

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

Data GambarGenerator akan membuat data X_training dari direktori. Subdirektori dalam direktori tersebut akan digunakan sebagai kelas untuk setiap objek. Gambar akan dimuat dengan mode warna RGB, dengan mode kelas kategorikal untuk data Y_training, dengan ukuran batch 16. Terakhir, kocok datanya.

Mari kita lihat gambar kita secara acak dengan memplotnya menggunakan matplotlib

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

Setelah itu mari kita buat model jaringan kita dari VGG16 dengan bobot terlatih imageNet. Kami akan membekukan lapisan ini sehingga lapisan tersebut tidak dapat dilatih untuk membantu kami mengurangi waktu komputasi.

Membuat Model kami dari VGG16

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

Seperti yang Anda lihat di bawah, ringkasan model jaringan kami. Dari masukan dari VGG16 Layers, kemudian kita tambahkan 2 Fully Connected Layer yang akan mengekstrak 1024 fitur dan satu output layer yang akan menghitung 8 kelas dengan aktivasi softmax.

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

Pelatihan

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

Hasil

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

Seperti yang Anda lihat, kerugian kami berkurang secara signifikan dan akurasinya hampir 100%. Untuk menguji model kami, kami mengambil gambar secara acak melalui internet dan meletakkannya di folder pengujian dengan kelas berbeda untuk diuji

Menguji Model Kami

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

Dan pengujian kami seperti yang diberikan di bawah ini! Hanya 1 gambar yang diprediksi salah dari pengujian 14 gambar!

Jaringan Syaraf Pengenalan Wajah dengan Keras

Mengapa kita membutuhkan Pengakuan

Kita membutuhkan Recognition untuk memudahkan kita mengenali atau mengidentifikasi wajah seseorang, jenis benda, perkiraan usia seseorang dari wajahnya, atau bahkan mengetahui ekspresi wajah orang tersebut.

Mungkin Anda menyadari setiap kali Anda mencoba menandai wajah teman Anda di sebuah foto, fitur di Facebook telah melakukannya untuk Anda, yaitu menandai wajah teman Anda tanpa Anda perlu menandainya terlebih dahulu. Inilah Face Recognition yang diterapkan Facebook untuk memudahkan kita menandai teman.

Jadi bagaimana cara kerjanya? Setiap kali kita menandai wajah teman kita, AI Facebook akan mempelajarinya dan mencoba memprediksinya hingga mendapatkan hasil yang tepat. Sistem yang sama akan kita gunakan untuk membuat Pengenalan Wajah kita sendiri. Mari mulai membuat Pengenalan Wajah kita sendiri menggunakan Deep Learning

Model Jaringan

Kami akan menggunakan Model Jaringan VGG16 tetapi dengan bobot VGGFace.

Arsitektur model VGG16

Apa itu VGGFace? Ini adalah implementasi Keras dari Deep Face Recognition yang diperkenalkan oleh Parkhi, Omkar M. et al. “Deep Face Recognition.” BMVC (2015). Kerangka kerja ini menggunakan VGG16 sebagai arsitektur jaringan.

Anda dapat mengunduh VGGFace dari github

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

Seperti yang Anda lihat ringkasan jaringan

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

kami akan melakukan a Transfer Belajar + Penyempurnaan untuk mempercepat pelatihan dengan kumpulan data kecil. Pertama, kita akan membekukan lapisan dasar sehingga lapisan tersebut tidak dapat dilatih.

for layer in face_model.layers:
    layer.trainable = False

lalu kita menambahkan layer kita sendiri untuk mengenali wajah pengujian kita. Kami akan menambahkan 2 lapisan yang terhubung sepenuhnya dan lapisan keluaran dengan 5 orang untuk dideteksi.

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

Mari kita lihat ringkasan jaringan kita

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

Seperti yang Anda lihat di atas, setelah lapisan pool5, lapisan tersebut akan diratakan menjadi satu vektor fitur yang akan digunakan oleh lapisan padat untuk pengenalan akhir.

Mempersiapkan Wajah kita

Sekarang mari kita persiapkan wajah kita. Saya membuat direktori yang terdiri dari 5 orang terkenal

• Jack Ma
• Jason Statham
• Johnny Depp
• Robert Downey Jr
• Rowan Atkinson

Setiap folder berisi 10 gambar, untuk setiap proses pelatihan dan evaluasi. Jumlah datanya sangat kecil, tetapi itulah tantangannya, bukan?

Kami akan menggunakan bantuan alat Keras untuk membantu kami menyiapkan data. Fungsi ini akan melakukan iterasi pada folder dataset lalu menyiapkannya agar dapat digunakan dalam pelatihan.

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

train_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

valid_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

Melatih Model Kami

Mari kita mulai proses pelatihan kita dengan mengkompilasi jaringan kita dengan fungsi kerugian dan pengoptimal. Di sini, kami menggunakan sparse_categorical_crossentropy sebagai fungsi kerugian, dengan bantuan SGD sebagai pengoptimal pembelajaran kami.

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

Seperti yang Anda lihat, akurasi validasi kami mencapai 64%, ini adalah hasil yang bagus untuk sejumlah kecil data pelatihan. Kita dapat memperbaikinya dengan menambahkan lebih banyak lapisan atau menambahkan lebih banyak gambar pelatihan sehingga model kita dapat mempelajari lebih lanjut tentang wajah dan mencapai akurasi yang lebih tinggi.

Mari kita uji model kita dengan gambar uji

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

menggunakan gambar Robert Downey Jr. sebagai gambar pengujian kami, ini menunjukkan bahwa wajah yang diprediksi itu benar!

Prediksi menggunakan Live Cam!

Bagaimana jika kita menguji kemampuan kita dengan mengimplementasikannya dengan masukan dari webcam? Menggunakan OpenCV dengan Haar Face cascade untuk menemukan wajah kita dan dengan bantuan model jaringan kita, kita dapat mengenali orang tersebut.

Langkah pertama adalah mempersiapkan wajah Anda dan teman Anda. Semakin banyak data yang kita miliki maka semakin baik hasilnya!

Persiapkan dan latih jaringan Anda seperti langkah sebelumnya, setelah pelatihan selesai, tambahkan baris ini untuk mendapatkan gambar masukan dari kamera

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

Mana yang lebih baik? Keras atau Tensorflow

Keras menawarkan kesederhanaan saat menulis naskah. Kita bisa mulai menulis dan memahaminya langsung dengan Keras karena tidak terlalu sulit untuk memahaminya. Lebih user-friendly dan mudah diimplementasikan, tidak perlu membuat banyak variabel untuk menjalankan model. Jadi, kita tidak perlu memahami setiap detail dalam proses backend.

Di sisi lain, Tensorflow adalah operasi tingkat rendah yang menawarkan fleksibilitas dan operasi tingkat lanjut jika Anda ingin membuat grafik atau model komputasi yang sewenang-wenang. Tensorflow juga dapat memvisualisasikan proses dengan bantuan Papan Tensor dan alat debugger khusus.

Jadi, jika Anda ingin mulai bekerja dengan deep learning tanpa terlalu banyak kerumitan, gunakan Keras. Karena Keras menawarkan kesederhanaan dan mudah digunakan serta mudah diimplementasikan daripada Tensorflow. Namun, jika Anda ingin menulis algoritme Anda sendiri dalam proyek atau penelitian deep learning, Anda harus menggunakan Tensorflow.

Kesimpulan

Jadi mari kita rangkum semua yang telah kita bahas dan lakukan dalam tutorial ini.

• Keras dalam API tingkat tinggi yang digunakan untuk membuat jaringan pembelajaran mendalam lebih mudah dengan bantuan mesin backend.
• Keras mudah digunakan dan dipahami dengan dukungan python sehingga terasa lebih alami dari sebelumnya. Ini bagus untuk pemula yang ingin mempelajari pembelajaran mendalam dan bagi peneliti yang ingin menggunakan API dengan mudah.
• Proses instalasinya mudah dan Anda dapat menggunakan lingkungan virtual atau menggunakan platform eksternal seperti AWS.
• Keras juga hadir dengan berbagai macam model jaringan sehingga memudahkan kita menggunakan model yang tersedia untuk pra-pelatihan dan penyempurnaan model jaringan kita sendiri.
• Selain itu, terdapat banyak tutorial dan artikel tentang penggunaan Keras dari komunitas kode di seluruh dunia untuk tujuan pembelajaran mendalam.