Keras - Panduan Cepat

Keras - Pendahuluan
Pembelajaran mendalam adalah salah satu subbidang utama kerangka pembelajaran mesin. Pembelajaran mesin adalah studi tentang desain algoritme, yang terinspirasi dari model otak manusia. Pembelajaran mendalam menjadi lebih populer di bidang ilmu data seperti robotika, kecerdasan buatan (AI), pengenalan audio & video, dan pengenalan gambar. Jaringan saraf tiruan adalah inti dari metodologi pembelajaran yang mendalam. Pembelajaran mendalam didukung oleh berbagai perpustakaan seperti Theano, TensorFlow, Caffe, Mxnet dll., Keras adalah salah satu perpustakaan python yang paling kuat dan mudah digunakan, yang dibangun di atas perpustakaan pembelajaran dalam populer seperti TensorFlow, Theano, dll. , untuk membuat model pembelajaran mendalam.

Gambaran Umum Keras

Keras berjalan di atas pustaka mesin sumber terbuka seperti TensorFlow, Theano, atau Cognitive Toolkit (CNTK). Theano adalah pustaka python yang digunakan untuk tugas komputasi numerik cepat. TensorFlow adalah pustaka matematika simbolis paling terkenal yang digunakan untuk membuat jaringan neural dan model pembelajaran mendalam. TensorFlow sangat fleksibel dan manfaat utamanya adalah komputasi terdistribusi. CNTK adalah kerangka pembelajaran mendalam yang dikembangkan oleh Microsoft. Ini menggunakan pustaka seperti Python, C #, C ++ atau toolkit pembelajaran mesin mandiri. Theano dan TensorFlow adalah library yang sangat kuat, tetapi sulit dipahami untuk membuat jaringan neural.

Keras didasarkan pada struktur minimal yang menyediakan cara yang bersih dan mudah untuk membuat model pembelajaran mendalam berdasarkan TensorFlow atau Theano. Keras dirancang untuk menentukan model pembelajaran dalam dengan cepat. Nah, Keras adalah pilihan optimal untuk aplikasi deep learning.

fitur

Keras memanfaatkan berbagai teknik pengoptimalan untuk membuat API jaringan saraf tingkat tinggi lebih mudah dan lebih berkinerja. Ini mendukung fitur-fitur berikut -

API yang konsisten, sederhana, dan dapat diperluas.
Struktur minimal - mudah untuk mencapai hasil tanpa embel-embel apapun.
Ini mendukung banyak platform dan backend.
Ini adalah kerangka kerja ramah pengguna yang berjalan pada CPU dan GPU.
Skalabilitas komputasi yang tinggi.

Manfaat

Keras adalah kerangka kerja yang sangat kuat dan dinamis dan hadir dengan keuntungan berikut -

Dukungan komunitas yang lebih besar.
Mudah untuk diuji.
Jaringan saraf keras ditulis dengan Python yang membuat segalanya lebih sederhana.
Keras mendukung jaringan konvolusi dan berulang.
Model deep learning merupakan komponen tersendiri, sehingga bisa Anda gabungkan menjadi banyak cara.

Keras - Instalasi

Bab ini menjelaskan tentang cara menginstal Keras di mesin Anda. Sebelum pindah ke instalasi, mari kita bahas persyaratan dasar Keras.

Prasyarat

Anda harus memenuhi persyaratan berikut -

Semua jenis OS (Windows, Linux atau Mac)
Python versi 3.5 atau lebih tinggi.

Python

Keras adalah pustaka jaringan saraf berbasis python sehingga python harus diinstal di komputer Anda. Jika python diinstal dengan benar di mesin Anda, kemudian buka terminal Anda dan ketik python, Anda dapat melihat respons yang serupa seperti yang ditentukan di bawah ini,

Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) 
[MSC v.1900 64 bit (AMD64)] on win32 
Type "help", "copyright", "credits" or "license" for more information. 
>>>

Sekarang versi terbaru adalah '3.7.2'. Jika Python belum diinstal, kunjungi tautan resmi python - www.python.org dan unduh versi terbaru berdasarkan OS Anda dan segera instal di sistem Anda.

Langkah Instalasi Keras

Instalasi keras cukup mudah. Ikuti langkah-langkah di bawah ini untuk menginstal Keras dengan benar di sistem Anda.

Langkah 1: Buat lingkungan virtual

Virtualenvdigunakan untuk mengelola paket Python untuk berbagai proyek. Ini akan membantu untuk menghindari kerusakan paket yang diinstal di lingkungan lain. Jadi, selalu disarankan untuk menggunakan lingkungan virtual saat mengembangkan aplikasi Python.

Linux/Mac OS

Pengguna Linux atau mac OS, buka direktori root proyek Anda dan ketik perintah di bawah ini untuk membuat lingkungan virtual,

python3 -m venv kerasenv

Setelah menjalankan perintah di atas, direktori “kerasenv” dibuat dengan bin,lib and include folders di lokasi instalasi Anda.

Windows

Pengguna Windows dapat menggunakan perintah di bawah ini,

py -m venv keras

Langkah 2: Aktifkan lingkungan

Langkah ini akan mengkonfigurasi executable python dan pip di jalur shell Anda.

Linux/Mac OS

Sekarang kami telah membuat lingkungan virtual bernama “kerasvenv”. Pindah ke folder dan ketik perintah di bawah ini,

$ cd kerasvenv kerasvenv $ source bin/activate

Windows

Pengguna Windows masuk ke dalam folder "kerasenv" dan ketik perintah di bawah ini,

.\env\Scripts\activate

Langkah 3: Perpustakaan Python

Keras bergantung pada pustaka python berikut.

Numpy
Pandas
Scikit-learn
Matplotlib
Scipy
Seaborn

Mudah-mudahan, Anda telah menginstal semua pustaka di atas di sistem Anda. Jika pustaka ini tidak diinstal, gunakan perintah di bawah ini untuk menginstal satu per satu.

numpy

pip install numpy

Anda bisa melihat respon berikut,

Collecting numpy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
   numpy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

pandas

pip install pandas

Kita bisa melihat respon berikut,

Collecting pandas 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
pandas-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

matplotlib

pip install matplotlib

Kita bisa melihat respon berikut,

Collecting matplotlib 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
matplotlib-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scipy

pip install scipy

Kita bisa melihat respon berikut,

Collecting scipy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8 
/scipy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scikit-learn

Ini adalah pustaka pembelajaran mesin sumber terbuka. Ini digunakan untuk klasifikasi, regresi dan algoritma pengelompokan. Sebelum pindah ke penginstalan, diperlukan hal-hal berikut -

Python versi 3.5 atau lebih tinggi
NumPy versi 1.11.0 atau lebih tinggi
SciPy versi 0.17.0 atau lebih tinggi
joblib 0.11 atau lebih tinggi.

Sekarang, kami menginstal scikit-learn menggunakan perintah di bawah ini -

pip install -U scikit-learn

Seaborn

Seaborn adalah perpustakaan luar biasa yang memungkinkan Anda memvisualisasikan data dengan mudah. Gunakan perintah di bawah ini untuk menginstal -

pip pip install seaborninstall -U scikit-learn

Anda bisa melihat pesan seperti yang ditentukan di bawah ini -

Collecting seaborn 
   Downloading 
https://files.pythonhosted.org/packages/a8/76/220ba4420459d9c4c9c9587c6ce607bf56c25b3d3d2de62056efe482dadc 
/seaborn-0.9.0-py3-none-any.whl (208kB) 100% 
   |████████████████████████████████| 215kB 4.0MB/s 
Requirement already satisfied: numpy> = 1.9.3 in 
./lib/python3.7/site-packages (from seaborn) (1.17.0) 
Collecting pandas> = 0.15.2 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/39/b7/441375a152f3f9929ff8bc2915218ff1a063a59d7137ae0546db616749f9/ 
pandas-0.25.0-cp37-cp37m-macosx_10_9_x86_64.
macosx_10_10_x86_64.whl (10.1MB) 100% 
   |████████████████████████████████| 10.1MB 1.8MB/s 
Requirement already satisfied: scipy>=0.14.0 in 
./lib/python3.7/site-packages (from seaborn) (1.3.0) 
Collecting matplotlib> = 1.4.3 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/c3/8b/af9e0984f
5c0df06d3fab0bf396eb09cbf05f8452de4e9502b182f59c33b/ 
matplotlib-3.1.1-cp37-cp37m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64 
.macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 100% 
   |████████████████████████████████| 14.4MB 1.4MB/s 
...................................... 
...................................... 
Successfully installed cycler-0.10.0 kiwisolver-1.1.0 
matplotlib-3.1.1 pandas-0.25.0 pyparsing-2.4.2 
python-dateutil-2.8.0 pytz-2019.2 seaborn-0.9.0

Instalasi Keras Menggunakan Python

Sampai sekarang, kami telah menyelesaikan persyaratan dasar untuk penginstalan Kera. Sekarang, instal Keras menggunakan prosedur yang sama seperti yang ditentukan di bawah ini -

pip install keras

Keluar dari lingkungan virtual

Setelah menyelesaikan semua perubahan Anda dalam proyek Anda, cukup jalankan perintah di bawah ini untuk keluar dari lingkungan -

deactivate

Anaconda Cloud

Kami yakin Anda telah menginstal anaconda cloud di komputer Anda. Jika anaconda belum diinstal, kunjungi tautan resminya, www.anaconda.com/distribution dan pilih unduh berdasarkan OS Anda.

Buat lingkungan conda baru

Luncurkan anaconda prompt, ini akan membuka lingkungan dasar Anaconda. Mari kita buat lingkungan conda baru. Proses ini mirip dengan virtualenv. Ketik perintah di bawah ini di terminal conda Anda -

conda create --name PythonCPU

Jika mau, Anda juga dapat membuat dan menginstal modul menggunakan GPU. Dalam tutorial ini, kami mengikuti instruksi CPU.

Aktifkan lingkungan conda

Untuk mengaktifkan lingkungan, gunakan perintah di bawah ini -

activate PythonCPU

Pasang spyder

Spyder adalah IDE untuk menjalankan aplikasi python. Mari kita instal IDE ini di lingkungan conda kita menggunakan perintah di bawah ini -

conda install spyder

Instal pustaka python

Kami telah mengetahui pustaka python numpy, pandas, dll., Yang dibutuhkan untuk keras. Anda dapat menginstal semua modul dengan menggunakan sintaks di bawah ini -

Syntax

conda install -c anaconda <module-name>

Misalnya, Anda ingin menginstal panda -

conda install -c anaconda pandas

Seperti metode yang sama, coba sendiri untuk menginstal modul yang tersisa.

Pasang Keras

Sekarang, semuanya terlihat baik jadi Anda bisa memulai instalasi keras menggunakan perintah di bawah ini -

conda install -c anaconda keras

Luncurkan spyder

Terakhir, luncurkan spyder di terminal conda Anda menggunakan perintah di bawah ini -

spyder

Untuk memastikan semuanya terpasang dengan benar, impor semua modul, itu akan menambahkan semuanya dan jika ada yang salah, Anda akan mendapatkannya module not found pesan eror.

Keras - Konfigurasi Backend

Bab ini menjelaskan implementasi backend Keras TensorFlow dan Theano secara mendetail. Mari kita bahas setiap penerapan satu per satu.

TensorFlow

TensorFlow adalah library machine learning open source yang digunakan untuk tugas komputasi numerik yang dikembangkan oleh Google. Keras adalah API tingkat tinggi yang dibangun di atas TensorFlow atau Theano. Kami sudah tahu cara menginstal TensorFlow menggunakan pip.

Jika tidak diinstal, Anda dapat menginstal menggunakan perintah di bawah ini -

pip install TensorFlow

Setelah kami mengeksekusi keras, kami dapat melihat file konfigurasi berada di direktori home Anda di dalam dan masuk ke .keras / keras.json.

keras.json.dll

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

Sini,

image_data_format mewakili format data.
epsilonmewakili konstanta numerik. Ini digunakan untuk menghindariDivideByZero kesalahan.
floatx mewakili tipe data default float32. Anda juga dapat mengubahnya menjadifloat16 atau float64 menggunakan set_floatx() metode.
image_data_format mewakili format data.

Misalkan, jika file tidak dibuat kemudian pindah ke lokasi dan buat menggunakan langkah-langkah di bawah ini -

> cd home 
> mkdir .keras 
> vi keras.json

Ingat, Anda harus menetapkan .keras sebagai nama foldernya dan menambahkan konfigurasi di atas ke dalam file keras.json. Kami dapat melakukan beberapa operasi yang ditentukan sebelumnya untuk mengetahui fungsi backend.

Theano

Theano adalah perpustakaan deep learning open source yang memungkinkan Anda mengevaluasi array multi-dimensi secara efektif. Kami dapat dengan mudah menginstal menggunakan perintah di bawah ini -

pip install theano

Secara default, keras menggunakan backend TensorFlow. Jika Anda ingin mengubah konfigurasi backend dari TensorFlow ke Theano, ubah saja backend = theano di file keras.json. Ini dijelaskan di bawah -

keras.json.dll

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

Sekarang simpan file Anda, restart terminal Anda dan mulai keras, backend Anda akan berubah.

>>> import keras as k 
using theano backend.

Keras - Ringkasan Deep learning

Pembelajaran mendalam adalah subbidang pembelajaran mesin yang berkembang. Pembelajaran mendalam melibatkan analisis masukan secara lapis demi lapis, di mana setiap lapisan secara progresif mengekstrak informasi tingkat yang lebih tinggi tentang masukan tersebut.

Mari kita ambil skenario sederhana untuk menganalisis gambar. Mari kita asumsikan bahwa gambar input Anda dibagi menjadi kotak piksel persegi panjang. Sekarang, lapisan pertama mengabstraksi piksel. Lapisan kedua memahami tepi pada gambar. Lapisan Berikutnya membangun simpul dari tepi. Kemudian, selanjutnya akan menemukan cabang dari node. Terakhir, lapisan keluaran akan mendeteksi objek secara penuh. Di sini, proses ekstraksi fitur beralih dari keluaran satu lapisan ke masukan lapisan berikutnya.

Dengan menggunakan pendekatan ini, kami dapat memproses sejumlah besar fitur, yang menjadikan pembelajaran mendalam sebagai alat yang sangat ampuh. Algoritme pembelajaran mendalam juga berguna untuk analisis data tidak terstruktur. Mari kita bahas dasar-dasar pembelajaran mendalam di bab ini.

Jaringan Syaraf Tiruan

Pendekatan pembelajaran dalam yang paling populer dan utama adalah menggunakan "Jaringan saraf tiruan" (JST). Mereka terinspirasi dari model otak manusia, yang merupakan organ paling kompleks di tubuh kita. Otak manusia terdiri dari lebih dari 90 miliar sel kecil yang disebut "Neuron". Neuron saling terhubung melalui serabut saraf yang disebut "akson" dan "Dendrit". Peran utama akson adalah mengirimkan informasi dari satu neuron ke neuron lain yang terhubung dengannya.

Demikian pula, peran utama dendrit adalah menerima informasi yang dikirimkan oleh akson dari neuron lain yang terhubung dengannya. Setiap neuron memproses informasi kecil dan kemudian meneruskan hasilnya ke neuron lain dan proses ini berlanjut. Ini adalah metode dasar yang digunakan oleh otak manusia kita untuk memproses banyak sekali informasi seperti ucapan, visual, dll., Dan mengekstrak informasi yang berguna darinya.

Berdasarkan model ini, Jaringan Syaraf Tiruan (JST) pertama ditemukan oleh psikolog Frank Rosenblatt, pada tahun 1958. JST terdiri dari beberapa node yang mirip dengan neuron. Node saling berhubungan erat dan diatur ke dalam lapisan tersembunyi yang berbeda. Lapisan masukan menerima data masukan dan data melewati satu atau lebih lapisan tersembunyi secara berurutan dan akhirnya lapisan keluaran memprediksi sesuatu yang berguna tentang data masukan. Misalnya, masukan mungkin berupa gambar dan keluaran mungkin hal yang diidentifikasi dalam gambar, katakan "Kucing".

Sebuah neuron tunggal (disebut perceptron di JST) dapat direpresentasikan seperti di bawah ini -

Sini,

Beberapa masukan bersama dengan bobot mewakili dendrit.
Jumlah input bersama dengan fungsi aktivasi mewakili neuron. Sum sebenarnya berarti nilai yang dihitung dari semua input dan fungsi aktivasi mewakili fungsi, yang memodifikasi Sum nilai menjadi 0, 1 atau 0 hingga 1.
Keluaran aktual merupakan akson dan keluaran tersebut akan diterima oleh neuron pada lapisan selanjutnya.

Mari kita pahami berbagai jenis jaringan saraf tiruan di bagian ini.

Perceptron Multi-Lapisan

Multi-Layer perceptron adalah bentuk JST yang paling sederhana. Ini terdiri dari satu lapisan masukan, satu atau lebih lapisan tersembunyi dan terakhir lapisan keluaran. Sebuah lapisan terdiri dari kumpulan perceptron. Lapisan masukan pada dasarnya adalah satu atau lebih fitur dari data masukan. Setiap lapisan tersembunyi terdiri dari satu atau lebih neuron dan memproses aspek tertentu dari fitur dan mengirimkan informasi yang telah diproses ke lapisan tersembunyi berikutnya. Proses lapisan keluaran menerima data dari lapisan tersembunyi terakhir dan akhirnya mengeluarkan hasilnya.

Jaringan Neural Konvolusional (CNN)

Jaringan saraf konvolusional adalah salah satu JST yang paling populer. Ini banyak digunakan di bidang pengenalan gambar dan video. Ini didasarkan pada konsep konvolusi, konsep matematika. Ini hampir mirip dengan multi-layer perceptron kecuali itu berisi rangkaian lapisan konvolusi dan lapisan penyatuan sebelum lapisan neuron tersembunyi yang terhubung sepenuhnya. Ini memiliki tiga lapisan penting -

Convolution layer - Ini adalah blok pembangun utama dan melakukan tugas komputasi berdasarkan fungsi konvolusi.
Pooling layer - Ini diatur di sebelah lapisan konvolusi dan digunakan untuk mengurangi ukuran input dengan menghilangkan informasi yang tidak perlu sehingga komputasi dapat dilakukan lebih cepat.
Fully connected layer - Ini diatur di sebelah rangkaian konvolusi dan lapisan penyatuan dan mengklasifikasikan input ke dalam berbagai kategori.

CNN sederhana dapat direpresentasikan seperti di bawah ini -

Sini,

2 seri Convolution dan pooling layer digunakan dan menerima dan memproses input (misalnya gambar).
Satu lapisan yang sepenuhnya terhubung digunakan dan digunakan untuk mengeluarkan data (misalnya klasifikasi gambar)

Jaringan Neural Berulang (RNN)

Recurrent Neural Networks (RNN) berguna untuk mengatasi kekurangan pada model ANN lainnya. Sebagian besar JST tidak mengingat langkah-langkah dari situasi sebelumnya dan belajar membuat keputusan berdasarkan konteks dalam pelatihan. Sementara itu, RNN menyimpan informasi masa lalu dan semua keputusannya diambil dari apa yang telah dipelajari dari masa lalu.

Pendekatan ini terutama berguna dalam klasifikasi gambar. Terkadang, kita mungkin perlu melihat ke masa depan untuk memperbaiki masa lalu. Dalam hal ini RNN dua arah berguna untuk belajar dari masa lalu dan memprediksi masa depan. Misalnya, kami memiliki contoh tulisan tangan dalam beberapa masukan. Misalkan kita mengalami kebingungan dalam satu masukan maka kita perlu memeriksa kembali masukan lainnya untuk mengenali konteks yang benar yang mengambil keputusan dari masa lalu.

Alur kerja ANN

Pertama-tama, mari kita pahami berbagai fase deep learning, lalu pelajari bagaimana Keras membantu dalam proses deep learning.

Kumpulkan data yang dibutuhkan

Pembelajaran mendalam membutuhkan banyak data masukan untuk berhasil mempelajari dan memprediksi hasilnya. Jadi, kumpulkan dulu data sebanyak mungkin.

Menganalisis data

Analisis data dan dapatkan pemahaman yang baik tentang data. Pemahaman yang lebih baik tentang data diperlukan untuk memilih algoritma JST yang benar.

Pilih algoritma (model)

Pilih algoritme, yang paling sesuai untuk jenis proses pembelajaran (misalnya klasifikasi gambar, pemrosesan teks, dll.) Dan data input yang tersedia. Algoritma diwakili olehModeldi Keras. Algoritma mencakup satu atau lebih lapisan. Setiap lapisan di ANN dapat diwakili olehKeras Layer di Keras.

Prepare data - Proses, filter, dan pilih hanya informasi yang diperlukan dari data.
Split data- Pisahkan data menjadi kumpulan data pelatihan dan pengujian. Data uji akan digunakan untuk mengevaluasi prediksi algoritma / Model (setelah pembelajaran mesin) dan untuk memeriksa ulang efisiensi proses pembelajaran.
Compile the model- Mengompilasi algoritma / model, sehingga dapat digunakan lebih lanjut untuk belajar dengan melatih dan terakhir melakukan prediksi. Langkah ini mengharuskan kita untuk memilih fungsi kerugian dan Pengoptimal. Fungsi loss dan Optimizer digunakan pada tahap pembelajaran untuk menemukan error (deviasi dari keluaran aktual) dan melakukan optimasi sehingga error tersebut dapat diminimalisir.
Fit the model - Proses pembelajaran yang sebenarnya akan dilakukan pada tahap ini menggunakan kumpulan data pelatihan.
Predict result for unknown value - Memprediksi keluaran untuk data masukan yang tidak diketahui (selain data pelatihan dan pengujian yang ada)
Evaluate model - Mengevaluasi model dengan memprediksi output untuk data pengujian dan membandingkan prediksi dengan hasil aktual dari data pengujian.
Freeze, Modify or choose new algorithm- Periksa apakah evaluasi model berhasil. Jika ya, simpan algoritme untuk tujuan prediksi di masa mendatang. Jika tidak, ubah atau pilih algoritme / model baru dan terakhir, latih lagi, prediksi, dan evaluasi model. Ulangi proses tersebut hingga algoritma (model) terbaik ditemukan.

Langkah-langkah di atas dapat direpresentasikan menggunakan diagram alir di bawah ini -

Keras - Pembelajaran mendalam

Keras menyediakan kerangka kerja lengkap untuk membuat semua jenis jaringan saraf. Keras itu inovatif sekaligus sangat mudah dipelajari. Ini mendukung jaringan saraf sederhana hingga model jaringan saraf yang sangat besar dan kompleks. Mari kita pahami arsitektur kerangka Keras dan bagaimana Keras membantu dalam pembelajaran mendalam di bab ini.

Arsitektur Keras

API Keras dapat dibagi menjadi tiga kategori utama -

Model
Layer
Modul Inti

Di Keras, setiap ANN diwakili oleh Keras Models. Pada gilirannya, setiap Model Keras adalah komposisiKeras Layers dan mewakili lapisan ANN seperti input, hidden layer, output layer, convolution layer, pooling layer, dll., model Keras dan akses lapisan Keras modules untuk fungsi aktivasi, fungsi kerugian, fungsi regularisasi, dll., Menggunakan model Keras, Lapisan Keras, dan modul Keras, semua algoritme JST (CNN, RNN, dll.,) dapat direpresentasikan dengan cara yang sederhana dan efisien.

Diagram berikut menggambarkan hubungan antara model, lapisan dan modul inti -

Mari kita lihat gambaran umum model Keras, lapisan Keras dan modul Keras.

Model

Model Keras terdiri dari dua jenis seperti yang disebutkan di bawah ini -

Sequential Model- Model sekuensial pada dasarnya adalah komposisi linier dari Keras Layers. Model sekuensial itu mudah, minimal, serta memiliki kemampuan untuk mewakili hampir semua jaringan neural yang tersedia.

Model sekuensial sederhana adalah sebagai berikut -

from keras.models import Sequential 
from keras.layers import Dense, Activation 
model = Sequential()  
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

Dimana,

Line 1 impor Sequential model dari model Keras
Line 2 impor Dense lapisan dan Activation modul
Line 4 buat model sekuensial baru menggunakan Sequential API
Line 5 menambahkan lapisan padat (Dense API) dengan relu aktivasi (menggunakan modul Aktivasi).

Sequential model mengekspos Modelkelas untuk membuat model yang disesuaikan juga. Kita dapat menggunakan konsep sub-classing untuk membuat model kompleks kita sendiri.

Functional API - API Fungsional pada dasarnya digunakan untuk membuat model yang kompleks.

Lapisan

Setiap lapisan Keras dalam model Keras mewakili lapisan yang sesuai (lapisan masukan, lapisan tersembunyi, dan lapisan keluaran) dalam model jaringan saraf tiruan yang sebenarnya. Keras menyediakan banyak lapisan pra-bangun sehingga jaringan saraf yang kompleks dapat dibuat dengan mudah. Beberapa lapisan Keras penting ditentukan di bawah ini,

Lapisan Inti
Lapisan Konvolusi
Pooling Layers
Lapisan Berulang

Kode python sederhana untuk mewakili model jaringan saraf menggunakan sequential modelnya adalah sebagai berikut -

from keras.models import Sequential 
from keras.layers import Dense, Activation, Dropout model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(num_classes, activation = 'softmax'))

Dimana,

Line 1 impor Sequential model dari model Keras
Line 2 impor Dense lapisan dan Activation modul
Line 4 buat model sekuensial baru menggunakan Sequential API
Line 5 menambahkan lapisan padat (Dense API) dengan relu aktivasi (menggunakan modul Aktivasi).
Line 6 menambahkan lapisan dropout (Dropout API) untuk menangani over-fitting.
Line 7 menambahkan lapisan padat lainnya (Dense API) dengan relu aktivasi (menggunakan modul Aktivasi).
Line 8 menambahkan lapisan dropout lainnya (Dropout API) untuk menangani over-fitting.
Line 9 menambahkan lapisan padat akhir (Dense API) dengan softmax aktivasi (menggunakan modul Aktivasi).

Keras juga menyediakan opsi untuk membuat lapisan khusus kita sendiri. Lapisan yang disesuaikan dapat dibuat dengan membuat sub-klasifikasi fileKeras.Layer class dan itu mirip dengan sub-classing model Keras.

Modul Inti

Keras juga menyediakan banyak fungsi terkait jaringan saraf bawaan untuk membuat model Keras dan lapisan Keras dengan benar. Beberapa fungsinya adalah sebagai berikut -

Activations module - Fungsi aktivasi adalah konsep penting dalam JST dan modul aktivasi menyediakan banyak fungsi aktivasi seperti softmax, relu, dll.,
Loss module - Modul kerugian menyediakan fungsi kerugian seperti mean_squared_error, mean_absolute_error, poisson, dll.,
Optimizer module - Modul pengoptimal menyediakan fungsi pengoptimal seperti adam, sgd, dll.,
Regularizers - Modul pengatur menyediakan fungsi seperti pengatur L1, pengatur L2, dll.,

Mari kita pelajari modul Keras secara mendetail di bab selanjutnya.

Keras - Modul

Seperti yang kita pelajari sebelumnya, modul Keras berisi kelas, fungsi, dan variabel yang telah ditentukan sebelumnya yang berguna untuk algoritme pembelajaran mendalam. Mari kita pelajari modul-modul yang disediakan oleh Keras di bab ini.

Modul yang tersedia

Mari kita lihat dulu daftar modul yang tersedia di Keras.

Initializers- Menyediakan daftar fungsi penginisialisasi. Kita bisa mempelajarinya secara detail di bab lapisan Keras . selama fase pembuatan model pembelajaran mesin.
Regularizers- Menyediakan daftar fungsi regulator. Secara detail kita bisa mempelajarinya di chapter Keras Layers .
Constraints- Menyediakan daftar fungsi kendala. Secara detail kita bisa mempelajarinya di chapter Keras Layers .
Activations- Menyediakan daftar fungsi aktivator. Secara detail kita bisa mempelajarinya di chapter Keras Layers .
Losses- Menyediakan daftar fungsi kerugian. Kita bisa mempelajarinya secara rinci di bab Pelatihan Model .
Metrics- Menyediakan daftar fungsi metrik. Kita bisa mempelajarinya secara rinci di bab Pelatihan Model .
Optimizers- Menyediakan daftar fungsi pengoptimal. Kita bisa mempelajarinya secara rinci di bab Pelatihan Model .
Callback- Menyediakan daftar fungsi panggilan balik. Kita dapat menggunakannya selama proses pelatihan untuk mencetak data perantara serta menghentikan pelatihan itu sendiri (EarlyStopping metode) berdasarkan beberapa kondisi.
Text processing- Menyediakan fungsi untuk mengubah teks menjadi larik NumPy yang cocok untuk pembelajaran mesin. Kita bisa menggunakannya dalam tahap persiapan data machine learning.
Image processing- Menyediakan fungsi untuk mengubah gambar menjadi array NumPy yang cocok untuk pembelajaran mesin. Kita bisa menggunakannya dalam tahap persiapan data machine learning.
Sequence processing- Menyediakan fungsi untuk menghasilkan data berbasis waktu dari data masukan yang diberikan. Kita bisa menggunakannya dalam tahap persiapan data machine learning.
Backend- Menyediakan fungsi perpustakaan backend seperti TensorFlow dan Theano .
Utilities - Menyediakan banyak fungsi utilitas yang berguna dalam pembelajaran mendalam.

Mari kita lihat backend modul dan utils model dalam bab ini.

modul backend

backend moduledigunakan untuk operasi keras backend. Secara default, keras berjalan di atas backend TensorFlow. Jika mau, Anda dapat beralih ke backend lain seperti Theano atau CNTK. Konfigurasi backend defualt didefinisikan di dalam direktori root Anda di bawah file .keras / keras.json.

Keras backend modul dapat diimpor dengan menggunakan kode di bawah

>>> from keras import backend as k

Jika kita menggunakan TensorFlow backend default , maka fungsi di bawah ini menampilkan informasi berbasis TensorFlow seperti yang ditentukan di bawah ini -

>>> k.backend() 
'tensorflow'
>>> k.epsilon() 
1e-07
>>> k.image_data_format() 
'channels_last'
>>> k.floatx() 
'float32'

Mari kita pahami beberapa fungsi backend penting yang digunakan untuk analisis data secara singkat -

get_uid ()

Ini adalah pengenal untuk grafik default. Ini didefinisikan di bawah -

>>> k.get_uid(prefix='') 
1 
>>> k.get_uid(prefix='') 2

reset_uids

Ini digunakan untuk mengatur ulang nilai uid.

>>> k.reset_uids()

Sekarang, jalankan kembali get_uid () . Ini akan diatur ulang dan diubah lagi menjadi 1.

>>> k.get_uid(prefix='') 
1

placeholder

Ini digunakan untuk memberi contoh tensor placeholder. Tempat penampung sederhana untuk menampung bentuk 3-D ditunjukkan di bawah ini -

>>> data = k.placeholder(shape = (1,3,3)) 
>>> data 
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32> 
If you use int_shape(), it will show the shape. 
>>> k.int_shape(data) (1, 3, 3)

dot

Ini digunakan untuk mengalikan dua tensor. Anggap a dan b adalah dua tensor dan c akan menjadi hasil perkalian dari ab. Asumsikan suatu bentuk adalah (4,2) dan bentuk b adalah (2,3). Ini didefinisikan di bawah,

>>> a = k.placeholder(shape = (4,2)) 
>>> b = k.placeholder(shape = (2,3)) 
>>> c = k.dot(a,b) 
>>> c 
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32> 
>>>

satu

Ini digunakan untuk menginisialisasi semua sebagai one nilai.

>>> res = k.ones(shape = (2,2)) 
#print the value 
>>> k.eval(res) 
array([[1., 1.], [1., 1.]], dtype = float32)

batch_dot

Ini digunakan untuk melakukan produk dari dua data dalam batch. Dimensi masukan harus 2 atau lebih tinggi. Itu ditunjukkan di bawah ini -

>>> a_batch = k.ones(shape = (2,3)) 
>>> b_batch = k.ones(shape = (3,2)) 
>>> c_batch = k.batch_dot(a_batch,b_batch) 
>>> c_batch 
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>

variabel

Ini digunakan untuk menginisialisasi variabel. Mari kita lakukan operasi transpose sederhana dalam variabel ini.

>>> data = k.variable([[10,20,30,40],[50,60,70,80]]) 
#variable initialized here 
>>> result = k.transpose(data) 
>>> print(result) 
Tensor("transpose_6:0", shape = (4, 2), dtype = float32) 
>>> print(k.eval(result)) 
   [[10. 50.] 
   [20. 60.] 
   [30. 70.] 
   [40. 80.]]

Jika Anda ingin mengakses dari numpy -

>>> data = np.array([[10,20,30,40],[50,60,70,80]]) 
>>> print(np.transpose(data)) 
   [[10 50] 
   [20 60] 
   [30 70] 
   [40 80]] 
>>> res = k.variable(value = data) 
>>> print(res) 
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>

is_sparse (tensor)

Ini digunakan untuk memeriksa apakah tensor jarang atau tidak.

>>> a = k.placeholder((2, 2), sparse=True) 
>>> print(a) SparseTensor(indices =       
   Tensor("Placeholder_8:0", 
   shape = (?, 2), dtype = int64), 
values = Tensor("Placeholder_7:0", shape = (?,), 
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64)) 
>>> print(k.is_sparse(a)) True

to_dense ()

Ini digunakan untuk mengubah sparse menjadi padat.

>>> b = k.to_dense(a) 
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32) 
>>> print(k.is_sparse(b)) False

random_uniform_variable

Ini digunakan untuk menginisialisasi penggunaan uniform distribution konsep.

k.random_uniform_variable(shape, mean, scale)

Sini,

shape - menunjukkan baris dan kolom dalam format tupel.
mean - rata-rata distribusi seragam.
scale - deviasi standar distribusi seragam.

Mari kita lihat contoh penggunaan di bawah ini -

>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1) 
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1) 
>>> c = k.dot(a, b) 
>>> k.int_shape(c) 
(2, 2)

modul utils

utilsmenyediakan fungsi utilitas yang berguna untuk pembelajaran mendalam. Beberapa metode yang disediakan olehutils modul adalah sebagai berikut -

HDF5Matrix

Ini digunakan untuk mewakili data input dalam format HDF5.

from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')

to_categorical

Ini digunakan untuk mengubah vektor kelas menjadi matriks kelas biner.

>>> from keras.utils import to_categorical 
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> to_categorical(labels) 
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize 
>>> normalize([1, 2, 3, 4, 5]) 
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])

print_summary

Ini digunakan untuk mencetak ringkasan model.

from keras.utils import print_summary print_summary(model)

plot_model

Ini digunakan untuk membuat representasi model dalam format titik dan menyimpannya ke file.

from keras.utils import plot_model 
plot_model(model,to_file = 'image.png')

Ini plot_model akan menghasilkan gambar untuk memahami kinerja model.

Keras - Lapisan

Seperti yang dipelajari sebelumnya, lapisan Keras adalah blok pembangun utama model Keras. Setiap lapisan menerima informasi masukan, melakukan beberapa perhitungan dan akhirnya mengeluarkan informasi yang diubah. Keluaran satu lapisan akan dialirkan ke lapisan berikutnya sebagai masukannya. Mari kita pelajari detail lengkap tentang lapisan di bab ini.

pengantar

Lapisan Keras membutuhkan shape of the input (input_shape) untuk memahami struktur data masukan, initializeruntuk menyetel bobot untuk setiap masukan dan terakhir penggerak untuk mengubah keluaran agar menjadi non-linier. Di antaranya, kendala membatasi dan menentukan kisaran di mana bobot data masukan yang akan dihasilkan dan regulator akan mencoba untuk mengoptimalkan lapisan (dan model) dengan secara dinamis menerapkan penalti pada bobot selama proses pengoptimalan.

Untuk meringkas, lapisan Keras membutuhkan detail minimum di bawah ini untuk membuat lapisan lengkap.

Bentuk data masukan
Jumlah neuron / unit di lapisan
Initializers
Regularizers
Constraints
Activations

Mari kita pahami konsep dasar di bab selanjutnya. Sebelum memahami konsep dasar, mari kita membuat lapisan Keras menggunakan API model Sequential untuk mendapatkan gambaran tentang cara kerja model dan lapisan Keras.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
from keras import regularizers 
from keras import constraints 
model = Sequential() 
model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform', 
   kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu')) 
model.add(Dense(16, activation = 'relu')) 
model.add(Dense(8))

dimana,

Line 1-5 mengimpor modul yang diperlukan.
Line 7 membuat model baru menggunakan Sequential API.
Line 9 menciptakan yang baru Dense lapisan dan menambahkannya ke dalam model. Denseadalah lapisan tingkat awal yang disediakan oleh Keras, yang menerima jumlah neuron atau unit (32) sebagai parameter yang diperlukan. Jika lapisannya adalah lapisan pertama, maka kita perlu menyediakannyaInput Shape, (16,)demikian juga. Jika tidak, keluaran dari lapisan sebelumnya akan digunakan sebagai masukan untuk lapisan berikutnya. Semua parameter lainnya bersifat opsional.
- Parameter pertama mewakili jumlah unit (neuron).
- input_shape mewakili bentuk data masukan.
- kernel_initializer mewakili penginisialisasi yang akan digunakan. he_uniform fungsi ditetapkan sebagai nilai.
- kernel_regularizer mewakili regularizeruntuk digunakan. Tidak ada yang ditetapkan sebagai nilai.
- kernel_constraint mewakili kendala untuk digunakan. MaxNorm fungsi ditetapkan sebagai nilai.
- activationmewakili aktivasi untuk digunakan. fungsi relu diset sebagai nilai.
Line 10 menciptakan yang kedua Dense lapisan dengan 16 unit dan set relu sebagai fungsi aktivasi.
Line 11 membuat lapisan Dense akhir dengan 8 unit.

Konsep Dasar Lapisan

Mari kita pahami konsep dasar layer serta bagaimana Keras mendukung setiap konsep.

Bentuk masukan

Dalam pembelajaran mesin, semua jenis data masukan seperti teks, gambar, atau video akan diubah terlebih dahulu menjadi deretan angka dan kemudian dimasukkan ke dalam algoritme. Nomor masukan dapat berupa larik berdimensi tunggal, larik dua dimensi (matriks), atau larik multidimensi. Kita dapat menentukan informasi dimensional menggunakanshape, tupel bilangan bulat. Sebagai contoh,(4,2) mewakili matriks dengan empat baris dan dua kolom.

>>> import numpy as np 
>>> shape = (4, 2) 
>>> input = np.zeros(shape) 
>>> print(input) 
[
   [0. 0.] 
   [0. 0.] 
   [0. 0.] 
   [0. 0.]
] 
>>>

Demikian pula, (3,4,2) matriks tiga dimensi memiliki tiga kumpulan matriks 4x2 (dua baris dan empat kolom).

>>> import numpy as np 
>>> shape = (3, 4, 2) 
>>> input = np.zeros(shape) 
>>> print(input)
[
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>

Untuk membuat lapisan pertama model (atau lapisan masukan model), bentuk data masukan harus ditentukan.

Penginisialisasi

Dalam Pembelajaran Mesin, bobot akan ditetapkan ke semua data masukan. Initializersmodul menyediakan fungsi yang berbeda untuk mengatur bobot awal ini. Beberapa dariKeras Initializer fungsinya adalah sebagai berikut -

Nol

Menghasilkan 0 untuk semua data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Zeros() 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Dimana, kernel_initializer mewakili penginisialisasi untuk kernel model.

Ones

Menghasilkan 1 untuk semua data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Ones() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Konstan

Menghasilkan nilai konstan (katakanlah, 5) ditentukan oleh pengguna untuk semua data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Constant(value = 0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

dimana, value mewakili nilai konstanta

RandomNormal

Menghasilkan nilai menggunakan distribusi normal data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.RandomNormal(mean=0.0, 
stddev = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

dimana,

mean mewakili mean dari nilai acak yang akan dihasilkan
stddev mewakili deviasi standar dari nilai acak yang akan dihasilkan
seed mewakili nilai untuk menghasilkan nomor acak

RandomUniform

Menghasilkan nilai menggunakan distribusi data input yang seragam.

from keras import initializers 
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

dimana,

minval mewakili batas bawah dari nilai acak yang akan dihasilkan
maxval mewakili batas atas dari nilai acak yang akan dihasilkan

TruncatedNormal

Menghasilkan nilai menggunakan distribusi normal data input yang terpotong.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

VarianceScaling

Menghasilkan nilai berdasarkan bentuk masukan dan bentuk keluaran dari lapisan bersama dengan skala yang ditentukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.VarianceScaling(
   scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   skernel_initializer = my_init))

dimana,

scale mewakili faktor penskalaan
mode mewakili salah satu dari fan_in, fan_out dan fan_avg nilai-nilai
distribution mewakili salah satu dari normal atau uniform

VarianceScaling

Ia menemukan stddev nilai distribusi normal menggunakan rumus di bawah ini dan kemudian mencari bobotnya menggunakan distribusi normal,

stddev = sqrt(scale / n)

dimana n mewakili,

jumlah unit masukan untuk mode = fan_in
jumlah unit keluar untuk mode = fan_out
jumlah rata-rata unit input dan output untuk mode = fan_avg

Demikian pula, ia menemukan batas untuk distribusi seragam menggunakan rumus di bawah ini dan kemudian menemukan bobotnya menggunakan distribusi seragam,

limit = sqrt(3 * scale / n)

lecun_normal

Menghasilkan nilai menggunakan lecun distribusi normal data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ia menemukan stddev menggunakan rumus di bawah ini dan kemudian menerapkan distribusi normal

stddev = sqrt(1 / fan_in)

dimana, fan_in mewakili jumlah unit masukan.

lecun_uniform

Menghasilkan nilai menggunakan distribusi data input yang seragam.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.lecun_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ia menemukan limit menggunakan rumus di bawah ini dan kemudian menerapkan distribusi seragam

limit = sqrt(3 / fan_in)

dimana,

fan_in mewakili jumlah unit masukan
fan_out mewakili jumlah unit keluaran

glorot_normal

Menghasilkan nilai menggunakan glorot distribusi normal data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.glorot_normal(seed=None) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

Ia menemukan stddev menggunakan rumus di bawah ini dan kemudian menerapkan distribusi normal

stddev = sqrt(2 / (fan_in + fan_out))

dimana,

fan_in mewakili jumlah unit masukan
fan_out mewakili jumlah unit keluaran

glorot_uniform

Menghasilkan nilai menggunakan distribusi seragam glorot dari data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.glorot_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ia menemukan limit menggunakan rumus di bawah ini dan kemudian menerapkan distribusi seragam

limit = sqrt(6 / (fan_in + fan_out))

dimana,

fan_in mewakili jumlah unit masukan.
fan_out mewakili jumlah unit keluaran

he_normal

Menghasilkan nilai menggunakan distribusi normal dari data masukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ia menemukan stddev menggunakan rumus di bawah ini dan kemudian menerapkan distribusi normal.

stddev = sqrt(2 / fan_in)

dimana, fan_in mewakili jumlah unit masukan.

he_uniform

Menghasilkan nilai menggunakan distribusi data input yang seragam.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.he_normal(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ia menemukan limit menggunakan rumus di bawah ini dan kemudian menerapkan distribusi seragam.

limit = sqrt(6 / fan_in)

dimana, fan_in mewakili jumlah unit masukan.

Ortogonal

Menghasilkan matriks ortogonal acak.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Orthogonal(gain = 1.0, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

dimana, gain mewakili faktor perkalian dari matriks.

Identitas

Menghasilkan matriks identitas.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

Kendala

Dalam pembelajaran mesin, batasan akan ditetapkan pada parameter (bobot) selama fase pengoptimalan. <> Modul batasan menyediakan fungsi yang berbeda untuk mengatur batasan pada lapisan. Beberapa fungsi kendala adalah sebagai berikut.

NonNeg

Batasi bobot menjadi non-negatif.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init)
)

dimana, kernel_constraint mewakili batasan yang akan digunakan di lapisan.

UnitNorm

Batasi bobot menjadi norma satuan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 
my_constrain = constraints.UnitNorm(axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

MaxNorm

Batasi bobot ke norma kurang dari atau sama dengan nilai yang diberikan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 
my_constrain = constraints.MaxNorm(max_value = 2, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

dimana,

max_value mewakili batas atas
sumbu mewakili dimensi di mana batasan akan diterapkan. misalnya dalam Bentuk (2,3,4) sumbu 0 menunjukkan dimensi pertama, 1 menunjukkan dimensi kedua dan 2 menunjukkan dimensi ketiga

MinMaxNorm

Membatasi bobot menjadi norma antara nilai minimum dan maksimum yang ditentukan.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 
my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

dimana, rate mewakili tingkat di mana batasan bobot diterapkan.

Regularizer

Dalam pembelajaran mesin, regulator digunakan dalam fase pengoptimalan. Ini menerapkan beberapa penalti pada parameter lapisan selama pengoptimalan. Modul regularisasi Keras menyediakan fungsi-fungsi di bawah ini untuk mengatur penalti pada lapisan. Regularisasi hanya berlaku per lapisan.

Regularizer L1

Ini menyediakan regularisasi berbasis L1.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 
my_regularizer = regularizers.l1(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

dimana, kernel_regularizer mewakili tingkat di mana batasan bobot diterapkan.

Pengatur L2

Ini menyediakan regularisasi berbasis L2.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 
my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

Regularizer L1 dan L2

Ini menyediakan regularisasi berbasis L1 dan L2.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 
my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,),
   kernel_regularizer = my_regularizer))

Aktivasi

Dalam pembelajaran mesin, fungsi aktivasi adalah fungsi khusus yang digunakan untuk mengetahui apakah neuron tertentu diaktifkan atau tidak. Pada dasarnya, fungsi aktivasi melakukan transformasi nonlinier dari data masukan dan dengan demikian memungkinkan neuron untuk belajar lebih baik. Keluaran neuron tergantung pada fungsi aktivasi.

Jika Anda mengingat kembali konsep persepsi tunggal, keluaran dari perceptron (neuron) hanyalah hasil dari fungsi aktivasi, yang menerima penjumlahan semua masukan dikalikan dengan bobot yang sesuai ditambah bias keseluruhan, jika ada.

result = Activation(SUMOF(input * weight) + bias)

Jadi, fungsi aktivasi memainkan peran penting dalam keberhasilan pembelajaran model. Keras menyediakan banyak fungsi aktivasi dalam modul aktivasi. Mari kita pelajari semua aktivasi yang tersedia di modul.

linier

Menerapkan fungsi Linear. Tidak melakukan apa-apa.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'linear', input_shape = (784,)))

Dimana, activationmengacu pada fungsi aktivasi lapisan. Ini dapat ditentukan hanya dengan nama fungsinya dan layer akan menggunakan aktivator yang sesuai.

elu

Menerapkan unit linier Eksponensial.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'elu', input_shape = (784,)))

selu

Menerapkan satuan linier eksponensial berskala.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'selu', input_shape = (784,)))

relu

Menerapkan Satuan Linear Rektifikasi.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

softmax.dll

Menerapkan fungsi Softmax.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))

softplus

Menerapkan fungsi Softplus.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))

softsign

Menerapkan fungsi Softsign.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))

tanh

Menerapkan fungsi tangen hiperbolik.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))

sigmoid.dll

Menerapkan fungsi Sigmoid.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))

hard_sigmoid

Menerapkan fungsi Hard Sigmoid.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))

eksponensial

Menerapkan fungsi eksponensial.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))

Sr Tidak	Lapisan & Deskripsi
1	Lapisan Padat Dense layer adalah lapisan jaringan saraf yang terhubung dalam.
2	Lapisan Putus Sekolah *Dropout* adalah salah satu konsep penting dalam pembelajaran mesin.
3	Ratakan Lapisan Flatten digunakan untuk meratakan masukan.
4	Bentuk Ulang Lapisan *Reshape* digunakan untuk mengubah bentuk input.
5	Lapisan Permute Permute juga digunakan untuk mengubah bentuk input menggunakan pola.
6	RepeatVector Layers *RepeatVector* digunakan untuk mengulang input untuk set nomor, n kali.
7	Lapisan Lambda *Lambda* digunakan untuk mengubah data masukan menggunakan ekspresi atau fungsi.
8	Lapisan Konvolusi Keras berisi banyak lapisan untuk membuat ANN berbasis Convolution, yang populer disebut Convolution Neural Network (CNN) .
9	Pooling Layer Ini digunakan untuk melakukan operasi penggabungan maksimal pada data temporal.
10	Lapisan yang terhubung secara lokal Lapisan yang terhubung secara lokal mirip dengan lapisan Konv1D tetapi perbedaannya adalah bobot lapisan Konv1D digunakan bersama tetapi di sini bobot tidak dibagi.
11	Gabungkan Lapisan Ini digunakan untuk menggabungkan daftar input.
12	Embedding Layer Ini melakukan operasi penyematan di lapisan masukan.

Keras - Lapisan Khusus

Keras memungkinkan untuk membuat lapisan kustom kita sendiri. Setelah lapisan baru dibuat, itu dapat digunakan dalam model apa pun tanpa batasan apa pun. Mari kita pelajari cara membuat layer baru di bab ini.

Keras menyediakan basis layerclass, Lapisan yang dapat disub-klasifikasikan untuk membuat lapisan kustom kita sendiri. Mari kita buat layer sederhana yang akan mencari bobot berdasarkan distribusi normal dan kemudian melakukan komputasi dasar untuk menemukan penjumlahan produk input dan bobotnya selama pelatihan.

Langkah 1: Impor modul yang diperlukan

Pertama, mari kita impor modul yang diperlukan -

from keras import backend as K 
from keras.layers import Layer

Sini,

backend digunakan untuk mengakses dot fungsi.
Layer adalah kelas dasar dan kami akan membuat sub-klasifikasinya untuk membuat lapisan kami

Langkah 2: Tentukan kelas lapisan

Mari kita buat kelas baru, MyCustomLayer dengan sub-klasifikasi Layer class -

class MyCustomLayer(Layer): 
   ...

Langkah 3: Inisialisasi kelas lapisan

Mari kita menginisialisasi kelas baru kita seperti yang ditentukan di bawah ini -

def __init__(self, output_dim, **kwargs):    
   self.output_dim = output_dim 
   super(MyCustomLayer, self).__init__(**kwargs)

Sini,

Line 2 mengatur dimensi keluaran.
Line 3 memanggil base atau lapisan super init fungsi.

Langkah 4: Terapkan metode build

buildadalah metode utama dan satu-satunya tujuan adalah membangun lapisan dengan benar. Itu bisa melakukan apa saja yang berhubungan dengan kerja bagian dalam lapisan. Setelah fungsionalitas kustom selesai, kita dapat memanggil kelas dasarbuildfungsi. Kebiasaan kamibuild fungsinya adalah sebagai berikut -

def build(self, input_shape): 
   self.kernel = self.add_weight(name = 'kernel', 
      shape = (input_shape[1], self.output_dim), 
      initializer = 'normal', trainable = True) 
   super(MyCustomLayer, self).build(input_shape)

Sini,

Line 1 mendefinisikan build metode dengan satu argumen, input_shape. Bentuk dari input data disebut dengan input_shape.
Line 2membuat bobot yang sesuai dengan bentuk masukan dan mengaturnya di kernel. Ini adalah fungsi kustom lapisan kami. Ini menciptakan bobot menggunakan penginisialisasi 'normal'.
Line 6 memanggil kelas dasar, build metode.

Langkah 5: Terapkan metode panggilan

call metode melakukan kerja lapisan yang tepat selama proses pelatihan.

Kebiasaan kami call metode adalah sebagai berikut

def call(self, input_data): 
   return K.dot(input_data, self.kernel)

Sini,

Line 1 mendefinisikan call metode dengan satu argumen, input_data. input_data adalah data masukan untuk lapisan kita.
Line 2 mengembalikan produk titik dari data masukan, input_data dan kernel lapisan kami, self.kernel

Langkah 6: Terapkan metode compute_output_shape

def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

Sini,

Line 1 mendefinisikan compute_output_shape metode dengan satu argumen input_shape
Line 2 menghitung bentuk keluaran menggunakan bentuk data masukan dan set dimensi keluaran saat menginisialisasi lapisan.

Menerapkan build, call dan compute_output_shapemenyelesaikan pembuatan lapisan yang disesuaikan. Kode terakhir dan lengkapnya adalah sebagai berikut

from keras import backend as K from keras.layers import Layer
class MyCustomLayer(Layer): 
   def __init__(self, output_dim, **kwargs): 
      self.output_dim = output_dim 
      super(MyCustomLayer, self).__init__(**kwargs) 
   def build(self, input_shape): self.kernel = 
      self.add_weight(name = 'kernel', 
      shape = (input_shape[1], self.output_dim), 
      initializer = 'normal', trainable = True) 
      super(MyCustomLayer, self).build(input_shape) # 
      Be sure to call this at the end 
   def call(self, input_data): return K.dot(input_data, self.kernel) 
   def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

Menggunakan lapisan khusus kami

Mari kita buat model sederhana menggunakan lapisan yang disesuaikan seperti yang ditentukan di bawah ini -

from keras.models import Sequential 
from keras.layers import Dense 
model = Sequential() 
model.add(MyCustomLayer(32, input_shape = (16,))) 
model.add(Dense(8, activation = 'softmax')) model.summary()

Sini,

Kami MyCustomLayer ditambahkan ke model menggunakan 32 unit dan (16,) sebagai bentuk masukan

Menjalankan aplikasi akan mencetak ringkasan model seperti di bawah ini -

Model: "sequential_1" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
my_custom_layer_1 (MyCustomL (None, 32) 512 
_________________________________________________________________
dense_1 (Dense) (None, 8) 264 
================================================================= 
Total params: 776 
Trainable params: 776 
Non-trainable params: 0 
_________________________________________________________________

Keras - Model

Seperti yang dipelajari sebelumnya, model Keras mewakili model jaringan neural yang sebenarnya. Keras menyediakan dua mode untuk membuat model, API Sequential sederhana dan mudah digunakan serta API Fungsional yang lebih fleksibel dan canggih . Mari kita pelajari sekarang untuk membuat model menggunakan Sequential dan Functional API di bab ini.

Sekuensial

Ide inti dari Sequential APIhanya mengatur lapisan Keras dalam urutan berurutan dan karenanya, disebut API Sekuensial . Sebagian besar JST juga memiliki lapisan dalam urutan yang berurutan dan data mengalir dari satu lapisan ke lapisan lain dalam urutan tertentu hingga data akhirnya mencapai lapisan keluaran.

Model ANN dapat dibuat hanya dengan menelepon Sequential() API seperti yang ditentukan di bawah ini -

from keras.models import Sequential 
model = Sequential()

Tambahkan lapisan

Untuk menambahkan lapisan, cukup buat lapisan menggunakan API lapisan Keras dan kemudian lewati lapisan melalui fungsi add () seperti yang ditentukan di bawah ini -

from keras.models import Sequential 
model = Sequential() 
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer) 
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer) 
output_layer = Dense(8) 
model.add(output_layer)

Di sini, kami telah membuat satu lapisan masukan, satu lapisan tersembunyi dan satu lapisan keluaran.

Akses modelnya

Keras menyediakan beberapa metode untuk mendapatkan informasi model seperti lapisan, data masukan, dan data keluaran. Mereka adalah sebagai berikut -

model.layers - Mengembalikan semua lapisan model sebagai daftar.

>>> layers = model.layers 
>>> layers 
[
   <keras.layers.core.Dense object at 0x000002C8C888B8D0>, 
   <keras.layers.core.Dense object at 0x000002C8C888B7B8>
   <keras.layers.core.Dense object at 0x 000002C8C888B898>
]

model.inputs - Menampilkan semua tensor input model sebagai daftar.

>>> inputs = model.inputs 
>>> inputs 
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]

model.outputs - Mengembalikan semua tensor keluaran model sebagai daftar.

>>> outputs = model.outputs 
>>> outputs 
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]

model.get_weights - Mengembalikan semua bobot sebagai array NumPy.
model.set_weights(weight_numpy_array) - Atur bobot model.

Serialisasi modelnya

Keras menyediakan metode untuk membuat serial model menjadi objek serta json dan memuatnya lagi nanti. Mereka adalah sebagai berikut -

get_config() - IRmengembalikan model sebagai objek.

config = model.get_config()

from_config() - Ini menerima objek konfigurasi model sebagai argumen dan membuat model yang sesuai.

new_model = Sequential.from_config(config)

to_json() - Mengembalikan model sebagai objek json.

>>> json_string = model.to_json() 
>>> json_string '{"class_name": "Sequential", "config": 
{"name": "sequential_10", "layers": 
[{"class_name": "Dense", "config": 
{"name": "dense_13", "trainable": true, "batch_input_shape": 
[null, 8], "dtype": "float32", "units": 32, "activation": "linear", 
"use_bias": true, "kernel_initializer": 
{"class_name": "Vari anceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf 
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, 
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true, 
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true, 
"kern el_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
"bias_initia lizer": {"class_name": "Zeros", 
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}}, 
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true, 
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true, 
"kernel_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}}, 
"bias_initializer": {"class_name": "Zeros", "config": {}}, 
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer": 
null, "kernel_constraint": null, "bias_constraint": 
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}' 
>>>

model_from_json() - Menerima representasi json dari model dan membuat model baru.

from keras.models import model_from_json 
new_model = model_from_json(json_string)

to_yaml() - Mengembalikan model sebagai string yaml.

>>> yaml_string = model.to_yaml() 
>>> yaml_string 'backend: tensorflow\nclass_name: 
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n 
activation: linear\n activity_regular izer: null\n batch_input_shape: 
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n 
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype: 
float32\n kernel_constraint: null\n 
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n 
trainable: true\n units: 32\n 
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n 
config : {}\n bias_regularizer: null\n dtype: float32\n 
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n 
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n 
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n 
units: 64\n use_bias: true\n - class_name: Dense\n config:\n 
activation: linear\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n 
class_name: Zeros\n config: {}\n bias_regu larizer: null\n 
dtype: float32\n kernel_constraint: null\n 
kernel_initializer:\n class_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n 
trainable: true\n units: 8\n 
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n' 
>>>

model_from_yaml() - Menerima representasi yaml dari model dan membuat model baru.

from keras.models import model_from_yaml 
new_model = model_from_yaml(yaml_string)

Rangkum modelnya

Memahami model adalah fase yang sangat penting untuk digunakan dengan benar untuk tujuan pelatihan dan prediksi. Keras menyediakan metode sederhana, ringkasan untuk mendapatkan informasi lengkap tentang model dan lapisannya.

Ringkasan model yang dibuat di bagian sebelumnya adalah sebagai berikut -

>>> model.summary() Model: "sequential_10" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
dense_13 (Dense) (None, 32) 288 
_________________________________________________________________ 
dense_14 (Dense) (None, 64) 2112 
_________________________________________________________________ 
dense_15 (Dense) (None, 8) 520 
================================================================= 
Total params: 2,920 
Trainable params: 2,920 
Non-trainable params: 0 
_________________________________________________________________ 
>>>

Latih dan Prediksi modelnya

Model menyediakan fungsi untuk proses pelatihan, evaluasi dan prediksi. Mereka adalah sebagai berikut -

compile - Konfigurasi proses pembelajaran model
fit - Latih model menggunakan data pelatihan
evaluate - Evaluasi model menggunakan data uji
predict - Memprediksi hasil untuk input baru.

API Fungsional

Sequential API digunakan untuk membuat model lapis demi lapis. API Fungsional adalah pendekatan alternatif untuk membuat model yang lebih kompleks. Model fungsional, Anda dapat menentukan beberapa masukan atau keluaran yang berbagi lapisan. Pertama, kami membuat instance untuk model dan menghubungkan ke lapisan untuk mengakses input dan output ke model. Bagian ini menjelaskan tentang model fungsional secara singkat.

Buat model

Impor lapisan masukan menggunakan modul di bawah ini -

>>> from keras.layers import Input

Sekarang, buat layer input yang menentukan bentuk dimensi input untuk model menggunakan kode di bawah ini -

>>> data = Input(shape=(2,3))

Tentukan lapisan untuk input menggunakan modul di bawah ini -

>>> from keras.layers import Dense

Tambahkan layer Dense untuk input menggunakan baris kode di bawah ini -

>>> layer = Dense(2)(data) 
>>> print(layer) 
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)

Tentukan model menggunakan modul di bawah ini -

from keras.models import Model

Buat model secara fungsional dengan menentukan lapisan input dan output -

model = Model(inputs = data, outputs = layer)

Kode lengkap untuk membuat model sederhana ditunjukkan di bawah ini -

from keras.layers import Input 
from keras.models import Model 
from keras.layers import Dense 
data = Input(shape=(2,3)) 
layer = Dense(2)(data) model = 
Model(inputs=data,outputs=layer) model.summary() 
_________________________________________________________________ 
Layer (type)               Output Shape               Param # 
================================================================= 
input_2 (InputLayer)       (None, 2, 3)               0 
_________________________________________________________________ 
dense_2 (Dense)            (None, 2, 2)               8 
================================================================= 
Total params: 8 
Trainable params: 8 
Non-trainable params: 0 
_________________________________________________________________

Keras - Kompilasi Model

Sebelumnya, kita telah mempelajari dasar-dasar cara membuat model menggunakan Sequential dan Functional API. Bab ini menjelaskan tentang cara mengompilasi model. Kompilasi adalah langkah terakhir dalam membuat model. Setelah kompilasi selesai, kita dapat melanjutkan ke fase pelatihan.

Mari kita pelajari beberapa konsep yang diperlukan untuk lebih memahami proses kompilasi.

Kerugian

Dalam pembelajaran mesin, LossFungsi digunakan untuk mencari kesalahan atau penyimpangan dalam proses pembelajaran. Keras membutuhkan fungsi kerugian selama proses kompilasi model.

Keras menyediakan cukup banyak fungsi kerugian di file losses modul dan mereka adalah sebagai berikut -

mean_squared_error
mean_absolute_error
mean_absolute_percentage_error
mean_squared_logarithmic_error
squared_hinge
hinge
categorical_hinge
logcosh
huber_loss
categorical_crossentropy
sparse_categorical_crossentropy
binary_crossentropy
kullback_leibler_divergence
poisson
cosine_proximity
is_categorical_crossentropy

Semua fungsi kerugian di atas menerima dua argumen -

y_true - label benar sebagai tensor
y_pred - prediksi dengan bentuk yang sama seperti y_true

Impor modul kerugian sebelum menggunakan fungsi kerugian seperti yang ditentukan di bawah ini -

from keras import losses

Pengoptimal

Dalam pembelajaran mesin, Optimizationadalah proses penting yang mengoptimalkan bobot input dengan membandingkan prediksi dan fungsi kerugian. Keras menyediakan beberapa pengoptimal sebagai modul, pengoptimal , dan mereka adalah sebagai berikut:

SGD - Pengoptimal penurunan gradien stokastik.

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

RMSprop - Pengoptimal RMSProp.

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

Adagrad - Pengoptimal Adagrad.

keras.optimizers.Adagrad(learning_rate = 0.01)

Adadelta - Pengoptimal Adadelta.

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

Adam - Pengoptimal Adam.

keras.optimizers.Adam(
   learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

Adamax - Pengoptimal Adamax dari Adam.

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Nadam - Pengoptimal Nesterov Adam.

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Impor modul pengoptimal sebelum menggunakan pengoptimal seperti yang ditentukan di bawah ini -

from keras import optimizers

Metrik

Dalam pembelajaran mesin, Metricsdigunakan untuk mengevaluasi kinerja model Anda. Ini mirip dengan fungsi kerugian, tetapi tidak digunakan dalam proses pelatihan. Keras menyediakan beberapa metrik sebagai modul,metrics dan mereka adalah sebagai berikut

accuracy
binary_accuracy
categorical_accuracy
sparse_categorical_accuracy
top_k_categorical_accuracy
sparse_top_k_categorical_accuracy
cosine_proximity
clone_metric

Mirip dengan fungsi kerugian, metrik juga menerima dua argumen di bawah ini -

y_true - label benar sebagai tensor
y_pred - prediksi dengan bentuk yang sama seperti y_true

Impor modul metrik sebelum menggunakan metrik seperti yang ditentukan di bawah ini -

from keras import metrics

Kompilasi model

Model keras menyediakan metode, compile()untuk mengkompilasi model. Argumen dan nilai default daricompile() metode adalah sebagai berikut

compile(
   optimizer, 
   loss = None, 
   metrics = None, 
   loss_weights = None, 
   sample_weight_mode = None, 
   weighted_metrics = None, 
   target_tensors = None
)

Argumen pentingnya adalah sebagai berikut -

fungsi kerugian
Optimizer
metrics

Contoh kode untuk mengkompilasi mode adalah sebagai berikut -

from keras import losses 
from keras import optimizers 
from keras import metrics 
model.compile(loss = 'mean_squared_error',  
   optimizer = 'sgd', metrics = [metrics.categorical_accuracy])

dimana,

fungsi kerugian ditetapkan sebagai mean_squared_error
pengoptimal disetel sebagai sgd
metrik ditetapkan sebagai metrics.categorical_accuracy

Pelatihan Model

Model dilatih oleh array NumPy menggunakan fit(). Tujuan utama dari fungsi fit ini digunakan untuk mengevaluasi model Anda pada pelatihan. Ini juga dapat digunakan untuk kinerja model grafik. Ini memiliki sintaks berikut -

model.fit(X, y, epochs = , batch_size = )

Sini,

X, y - Ini adalah tupel untuk mengevaluasi data Anda.
epochs - berapa kali model perlu dievaluasi selama pelatihan.
batch_size - contoh pelatihan.

Mari kita ambil contoh sederhana dari data acak numpy untuk menggunakan konsep ini.

Buat data

Mari kita buat data acak menggunakan numpy untuk x dan y dengan bantuan perintah yang disebutkan di bawah ini -

import numpy as np 
x_train = np.random.random((100,4,8)) 
y_train = np.random.random((100,10))

Sekarang, buat data validasi acak,

x_val = np.random.random((100,4,8)) 
y_val = np.random.random((100,10))

Buat model

Mari kita buat model sekuensial sederhana -

from keras.models import Sequential model = Sequential()

Tambahkan lapisan

Buat lapisan untuk menambahkan model -

from keras.layers import LSTM, Dense 
# add a sequence of vectors of dimension 16 
model.add(LSTM(16, return_sequences = True)) 
model.add(Dense(10, activation = 'softmax'))

model kompilasi

Sekarang model telah ditentukan. Anda dapat mengkompilasi menggunakan perintah di bawah ini -

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

Terapkan fit ()

Sekarang kami menerapkan fungsi fit () untuk melatih data kami -

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

Buat JST Perceptron Multi-Layer

Kami telah belajar membuat, mengkompilasi dan melatih model Keras.

Mari kita terapkan pembelajaran kita dan membuat JST berbasis MPL sederhana.

Modul set data

Sebelum membuat model, kita perlu memilih masalah, perlu mengumpulkan data yang diperlukan dan mengonversi data ke array NumPy. Setelah data terkumpul, kita dapat menyiapkan model dan melatihnya dengan menggunakan data yang telah dikumpulkan. Pengumpulan data adalah salah satu fase pembelajaran mesin yang paling sulit. Keras menyediakan modul khusus, dataset untuk mengunduh data pembelajaran mesin online untuk keperluan pelatihan. Ini mengambil data dari server online, memproses data dan mengembalikan data sebagai set pelatihan dan pengujian. Mari kita periksa data yang diberikan oleh modul dataset Keras. Data yang tersedia dalam modul adalah sebagai berikut,

Klasifikasi gambar kecil CIFAR10
Klasifikasi gambar kecil CIFAR100
Film IMDB meninjau klasifikasi sentimen
Klasifikasi topik berita Reuters
Database MNIST dari digit tulisan tangan
Database fashion-MNIST artikel fashion
Dataset regresi harga perumahan Boston

Mari kita gunakan MNIST database of handwritten digits(atau minst) sebagai masukan kami. minst adalah kumpulan 60.000, gambar abu-abu 28x28. Ini berisi 10 digit. Ini juga berisi 10.000 gambar uji.

Kode di bawah ini dapat digunakan untuk memuat dataset -

from keras.datasets import mnist 
(x_train, y_train), (x_test, y_test) = mnist.load_data()

dimana

Line 1 impor minst dari modul keras dataset.
Line 3 memanggil load_data fungsi, yang akan mengambil data dari server online dan mengembalikan data sebagai 2 tupel, tupel pertama, (x_train, y_train) mewakili data pelatihan dengan bentuk, (number_sample, 28, 28) dan label digitnya dengan bentuk, (number_samples, ). Tupel kedua,(x_test, y_test) merepresentasikan data uji dengan bentuk yang sama.

Dataset lain juga dapat diambil menggunakan API yang serupa dan setiap API mengembalikan data yang serupa juga kecuali bentuk datanya. Bentuk datanya bergantung pada jenis datanya.

Buat model

Mari kita memilih multi-layer perceptron (MLP) sederhana seperti yang ditunjukkan di bawah ini dan mencoba membuat model menggunakan Keras.

Fitur inti dari model ini adalah sebagai berikut -

Lapisan masukan terdiri dari 784 nilai (28 x 28 = 784).
Lapisan tersembunyi pertama, Dense terdiri dari 512 neuron dan fungsi aktivasi 'relu'.
Lapisan tersembunyi kedua, Dropout memiliki 0,2 sebagai nilainya.
Lapisan tersembunyi ketiga, lagi Dense terdiri dari 512 neuron dan fungsi aktivasi 'relu'.
Lapisan tersembunyi keempat, Dropout memiliki 0,2 sebagai nilainya.
Lapisan kelima dan terakhir terdiri dari 10 neuron dan fungsi aktivasi 'softmax'.
Menggunakan categorical_crossentropy sebagai fungsi kerugian.
Menggunakan RMSprop() 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 
from keras.optimizers import RMSprop 
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.

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
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)

Dimana

reshape digunakan untuk membentuk kembali input dari (28, 28) tuple ke (784,)
to_categorical digunakan untuk mengubah vektor menjadi matriks biner

Step 4 − Create the model

Mari kita buat model sebenarnya.

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2)) 
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 = 'categorical_crossentropy',     
   optimizer = RMSprop(), 
   metrics = ['accuracy'])

Step 6 − Train the model

Mari kita latih modelnya menggunakan fit() metode.

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

Pikiran terakhir

Kami telah membuat model, memuat data, dan juga melatih data ke model. Kita masih perlu mengevaluasi model dan memprediksi keluaran untuk masukan yang tidak diketahui, yang akan kita pelajari di bab selanjutnya.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np 
(x_train, y_train), (x_test, y_test) = mnist.load_data() 
x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
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) 
model = Sequential() 
model.add(Dense(512, activation='relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', 
   optimizer = RMSprop(), 
   metrics = ['accuracy']) 
history = model.fit(x_train, y_train, 
   batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

Menjalankan aplikasi akan memberikan konten di bawah ini sebagai output -

Train on 60000 samples, validate on 10000 samples Epoch 1/20 
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453 
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023 
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744 
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599 
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504 
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20 
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438 
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20 
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391 
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364 
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308 
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289 
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279 
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260 
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257 
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229 
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20 
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235 
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214 
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219 
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190 
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197 
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198 
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828

Keras - Evaluasi Model dan Prediksi Model

Bab ini membahas evaluasi model dan prediksi model di Keras.

Mari kita mulai dengan memahami evaluasi model.

Evaluasi Model

Evaluasi adalah proses selama pengembangan model untuk memeriksa apakah model paling cocok untuk masalah yang diberikan dan data yang sesuai. Model keras menyediakan fungsi, evaluasi yang melakukan evaluasi model. Ini memiliki tiga argumen utama,

Uji data
Uji label data
verbose - benar atau salah

Mari kita evaluasi model, yang kita buat di bab sebelumnya 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.

Akurasi tes adalah 98,28%. Kami telah membuat model terbaik untuk mengidentifikasi angka tulisan tangan. Sisi positifnya, kami masih dapat meningkatkan model kami.

Prediksi Model

Predictionadalah langkah terakhir dan hasil yang kami harapkan dari generasi model. Keras menyediakan metode, memprediksi untuk mendapatkan prediksi model yang dilatih. Tanda tangan dari metode prediksi adalah sebagai berikut,

predict(
   x, 
   batch_size = None, 
   verbose = 0, 
   steps = None, 
   callbacks = None, 
   max_queue_size = 10, 
   workers = 1, 
   use_multiprocessing = False
)

Di sini, semua argumen bersifat opsional kecuali argumen pertama, yang merujuk data input yang tidak diketahui. Bentuknya harus dipertahankan untuk mendapatkan prediksi yang tepat.

Mari kita lakukan prediksi untuk model MPL kita yang dibuat di bab sebelumnya menggunakan kode 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)

Sini,

Line 1 panggil fungsi prediksi menggunakan data pengujian.
Line 2 mendapat lima prediksi pertama
Line 3 mendapatkan lima label pertama dari data pengujian.
Line 5 - 6 mencetak prediksi dan label aktual.

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.

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.

Keras - Prediksi Regresi menggunakan MPL

Dalam bab ini, mari kita tulis JST berbasis MPL sederhana untuk melakukan prediksi regresi. Selama ini kami baru melakukan prediksi berbasis klasifikasi. Sekarang, kita akan mencoba memprediksi nilai yang mungkin berikutnya dengan menganalisis nilai sebelumnya (berkelanjutan) dan faktor-faktor yang mempengaruhinya.

MPL Regresi dapat direpresentasikan sebagai berikut -

Fitur inti dari model ini adalah sebagai berikut -

Lapisan masukan terdiri dari (13) nilai.
Lapisan pertama, Dense terdiri dari 64 unit dan fungsi aktivasi 'relu' dengan penginisialisasi kernel 'normal'.
Lapisan kedua, Dense terdiri dari 64 unit dan fungsi aktivasi 'relu'.
Output layer, Dense terdiri dari 1 unit.
Menggunakan mse sebagai fungsi kerugian.
Menggunakan RMSprop sebagai Pengoptimal.
Menggunakan accuracy sebagai metrik.
Gunakan 128 sebagai ukuran batch.
Gunakan 500 sebagai epoch.

Step 1 − Import the modules

Mari kita impor modul yang diperlukan.

import keras 
from keras.datasets import boston_housing 
from keras.models import Sequential 
from keras.layers import Dense 
from keras.optimizers import RMSprop 
from keras.callbacks import EarlyStopping 
from sklearn import preprocessing 
from sklearn.preprocessing import scale

Step 2 − Load data

Mari kita impor dataset perumahan Boston.

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

Sini,

boston_housingadalah kumpulan data yang disediakan oleh Keras. Ini mewakili kumpulan informasi perumahan di wilayah Boston, masing-masing memiliki 13 fitur.

Step 3 − Process the data

Mari kita ubah dataset sesuai dengan model kita, sehingga kita bisa memasukkan ke dalam model kita. Data dapat diubah menggunakan kode di bawah ini -

x_train_scaled = preprocessing.scale(x_train) 
scaler = preprocessing.StandardScaler().fit(x_train) 
x_test_scaled = scaler.transform(x_test)

Di sini, kami telah menormalkan data pelatihan menggunakan sklearn.preprocessing.scale fungsi. preprocessing.StandardScaler().fit fungsi mengembalikan skalar dengan mean dan deviasi standar yang dinormalisasi dari data pelatihan, yang dapat kita terapkan ke data uji menggunakan scalar.transformfungsi. Ini akan menormalkan data pengujian juga dengan pengaturan yang sama seperti data pelatihan.

Step 4 − Create the model

Mari kita buat model sebenarnya.

model = Sequential() 
model.add(Dense(64, kernel_initializer = 'normal', activation = 'relu',
input_shape = (13,))) 
model.add(Dense(64, activation = 'relu')) model.add(Dense(1))

Step 5 − Compile the model

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

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

Step 6 − Train the model

Mari kita latih modelnya menggunakan fit() metode.

history = model.fit(
   x_train_scaled, y_train,    
   batch_size=128, 
   epochs = 500, 
   verbose = 1, 
   validation_split = 0.2, 
   callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20)]
)

Di sini, kami telah menggunakan fungsi panggilan balik, EarlyStopping. Tujuan dari callback ini adalah untuk memantau nilai kerugian pada setiap epoch dan membandingkannya dengan nilai kerugian epoch sebelumnya untuk mengetahui peningkatan dalam pelatihan. Jika tidak ada perbaikan untukpatience kali, maka seluruh proses akan dihentikan.

Menjalankan aplikasi akan memberikan informasi di bawah ini sebagai output -

Train on 323 samples, validate on 81 samples Epoch 1/500 2019-09-24 01:07:03.889046: I 
tensorflow/core/platform/cpu_feature_guard.cc:142] 
Your CPU supports instructions that this 
TensorFlow binary was not co mpiled to use: AVX2 323/323 
[==============================] - 0s 515us/step - loss: 562.3129 
- mean_absolute_error: 21.8575 - val_loss: 621.6523 - val_mean_absolute_erro 
r: 23.1730 Epoch 2/500 
323/323 [==============================] - 0s 11us/step - loss: 545.1666 
- mean_absolute_error: 21.4887 - val_loss: 605.1341 - val_mean_absolute_error 
: 22.8293 Epoch 3/500 
323/323 [==============================] - 0s 12us/step - loss: 528.9944 
- mean_absolute_error: 21.1328 - val_loss: 588.6594 - val_mean_absolute_error 
: 22.4799 Epoch 4/500 
323/323 [==============================] - 0s 12us/step - loss: 512.2739 
- mean_absolute_error: 20.7658 - val_loss: 570.3772 - val_mean_absolute_error 
: 22.0853 Epoch 5/500
323/323 [==============================] - 0s 9us/step - loss: 493.9775 
- mean_absolute_error: 20.3506 - val_loss: 550.9548 - val_mean_absolute_error: 21.6547 
.......... 
.......... 
.......... 
Epoch 143/500 
323/323 [==============================] - 0s 15us/step - loss: 8.1004 
- mean_absolute_error: 2.0002 - val_loss: 14.6286 - val_mean_absolute_error: 
2. 5904 Epoch 144/500 
323/323 [==============================] - 0s 19us/step - loss: 8.0300 
- mean_absolute_error: 1.9683 - val_loss: 14.5949 - val_mean_absolute_error: 
2. 5843 Epoch 145/500 
323/323 [==============================] - 0s 12us/step - loss: 7.8704 
- mean_absolute_error: 1.9313 - val_loss: 14.3770 - val_mean_absolute_error: 2. 4996

Step 7 − Evaluate the model

Mari kita evaluasi model menggunakan data uji.

score = model.evaluate(x_test_scaled, 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: 21.928471583946077 Test accuracy: 2.9599233234629914

Step 8 − Predict

Terakhir, prediksi menggunakan data uji seperti di bawah ini -

prediction = model.predict(x_test_scaled) 
print(prediction.flatten()) 
print(y_test)

Output dari aplikasi di atas adalah sebagai berikut -

[ 7.5612316 17.583357 21.09344 31.859276 25.055613 18.673872 26.600405 22.403967 19.060272 22.264952 
17.4191 17.00466 15.58924 41.624374 20.220217 18.985565 26.419338 19.837091 19.946192 36.43445 
12.278508 16.330965 20.701359 14.345301 21.741161 25.050423 31.046402 27.738455 9.959419 20.93039 
20.069063 14.518344 33.20235 24.735163 18.7274 9.148898 15.781284 18.556862 18.692865 26.045074 
27.954073 28.106823 15.272034 40.879818 29.33896 23.714525 26.427515 16.483374 22.518442 22.425386 
33.94826 18.831465 13.2501955 15.537227 34.639984 27.468002 13.474407 48.134598 34.39617 
22.8503124.042334 17.747198 14.7837715 18.187277 23.655672 22.364983 13.858193 22.710032 14.371148 
7.1272087 35.960033 28.247292 25.3014 14.477208 25.306196 17.891165 20.193708 23.585173 34.690193 
12.200583 20.102983 38.45882 14.741723 14.408362 17.67158 18.418497 21.151712 21.157492 22.693687 
29.809034 19.366991 20.072294 25.880817 40.814568 34.64087 19.43741 36.2591 50.73806 26.968863 43.91787 
32.54908 20.248306 ] [ 7.2 18.8 19. 27. 22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50. 20.8 24.3 24.2 
19.8 19.1 22.7 12. 10.2 20. 18.5 20.9 23. 27.5 30.1 9.5 22. 21.2 14.1 33.1 23.4 20.1 7.4 15.4 23.8 20.1 
24.5 33. 28.4 14.1 46.7 32.5 29.6 28.4 19.8 20.2 25. 35.4 20.3 9.7 14.5 34.9 26.6 7.2 50. 32.4 21.6 29.8 
13.1 27.5 21.2 23.1 21.9 13. 23.2 8.1 5.6 21.7 29.6 19.6 7. 26.4 18.9 20.9 28.1 35.4 10.2 24.3 43.1 17.6 
15.4 16.2 27.1 21.4 21.5 22.4 25. 16.6 18.6 22. 42.8 35.1 21.5 36. 21.9 24.1 50. 26.7 25. ]

Output dari kedua larik memiliki perbedaan sekitar 10-30% dan ini menunjukkan model kami memprediksi dengan rentang yang wajar.

Keras - Prediksi Rangkaian Waktu menggunakan LSTM RNN

Dalam bab ini, mari kita tulis RNN berbasis Long Short Term Memory (LSTM) sederhana untuk melakukan analisis urutan. Urutan adalah sekumpulan nilai di mana setiap nilai sesuai dengan contoh waktu tertentu. Mari kita perhatikan contoh sederhana membaca kalimat. Membaca dan memahami kalimat melibatkan membaca kata dalam urutan tertentu dan mencoba memahami setiap kata dan artinya dalam konteks yang diberikan dan akhirnya memahami kalimat dalam sentimen positif atau negatif.

Di sini, kata-kata dianggap sebagai nilai, dan nilai pertama sesuai dengan kata pertama, nilai kedua sesuai dengan kata kedua, dll., Dan urutannya akan dipertahankan dengan ketat. Sequence Analysis sering digunakan dalam pemrosesan bahasa alami untuk menemukan analisis sentimen dari teks yang diberikan.

Mari kita buat model LSTM untuk menganalisis review film IMDB dan menemukan sentimen positif / negatifnya.

Model untuk analisis sekuens dapat direpresentasikan sebagai berikut -

Fitur inti dari model ini adalah sebagai berikut -

Input layer menggunakan lapisan Embedding dengan 128 fitur.
Layer pertama, Dense terdiri dari 128 unit dengan dropout normal dan dropout berulang diatur ke 0.2.
Output layer, Dense terdiri dari 1 unit dan fungsi aktivasi 'sigmoid'.
Menggunakan binary_crossentropy sebagai fungsi kerugian.
Menggunakan adam sebagai Pengoptimal.
Menggunakan accuracy sebagai metrik.
Gunakan 32 sebagai ukuran batch.
Gunakan 15 sebagai epoch.
Gunakan 80 sebagai panjang maksimum kata.
Gunakan 2000 sebagai jumlah kata maksimum dalam kalimat tertentu.

Langkah 1: Impor modul

Mari kita impor modul yang diperlukan.

from keras.preprocessing import sequence 
from keras.models import Sequential 
from keras.layers import Dense, Embedding 
from keras.layers import LSTM 
from keras.datasets import imdb

Langkah 2: Muat data

Mari kita impor dataset imdb.

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words = 2000)

Sini,

imdbadalah kumpulan data yang disediakan oleh Keras. Ini mewakili kumpulan film dan ulasannya.
num_words mewakili jumlah kata maksimum dalam ulasan.

Langkah 3: Proses data

Mari kita ubah dataset sesuai dengan model kita, sehingga bisa dimasukkan ke dalam model kita. Data dapat diubah menggunakan kode di bawah ini -

x_train = sequence.pad_sequences(x_train, maxlen=80) 
x_test = sequence.pad_sequences(x_test, maxlen=80)

Sini,

sequence.pad_sequences mengkonversi daftar data masukan dengan bentuk, (data) ke dalam array bentuk NumPy 2D (data, timesteps). Pada dasarnya, ini menambahkan konsep waktu ke dalam data yang diberikan. Ini menghasilkan panjang langkah,maxlen.

Langkah 4: Buat model

Mari kita buat model sebenarnya.

model = Sequential() 
model.add(Embedding(2000, 128)) 
model.add(LSTM(128, dropout = 0.2, recurrent_dropout = 0.2)) 
model.add(Dense(1, activation = 'sigmoid'))

Sini,

Kami telah menggunakan Embedding layersebagai lapisan masukan dan kemudian ditambahkan lapisan LSTM. Akhirnya, aDense layer digunakan sebagai lapisan keluaran.

Langkah 5: Kompilasi model

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

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

Langkah 6: Latih modelnya

Izinkan kami melatih model menggunakan fit() metode.

model.fit(
   x_train, y_train, 
   batch_size = 32, 
   epochs = 15, 
   validation_data = (x_test, y_test)
)

Menjalankan aplikasi akan menampilkan informasi di bawah ini -

Epoch 1/15 2019-09-24 01:19:01.151247: I 
tensorflow/core/platform/cpu_feature_guard.cc:142] 
Your CPU supports instructions that this 
TensorFlow binary was not co mpiled to use: AVX2 
25000/25000 [==============================] - 101s 4ms/step - loss: 0.4707 
- acc: 0.7716 - val_loss: 0.3769 - val_acc: 0.8349 Epoch 2/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.3058 
- acc: 0.8756 - val_loss: 0.3763 - val_acc: 0.8350 Epoch 3/15 
25000/25000 [==============================] - 91s 4ms/step - loss: 0.2100 
- acc: 0.9178 - val_loss: 0.5065 - val_acc: 0.8110 Epoch 4/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.1394 
- acc: 0.9495 - val_loss: 0.6046 - val_acc: 0.8146 Epoch 5/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0973 
- acc: 0.9652 - val_loss: 0.5969 - val_acc: 0.8147 Epoch 6/15 
25000/25000 [==============================] - 98s 4ms/step - loss: 0.0759 
- acc: 0.9730 - val_loss: 0.6368 - val_acc: 0.8208 Epoch 7/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0578 
- acc: 0.9811 - val_loss: 0.6657 - val_acc: 0.8184 Epoch 8/15 
25000/25000 [==============================] - 97s 4ms/step - loss: 0.0448 
- acc: 0.9850 - val_loss: 0.7452 - val_acc: 0.8136 Epoch 9/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0324 
- acc: 0.9894 - val_loss: 0.7616 - val_acc: 0.8162Epoch 10/15 
25000/25000 [==============================] - 100s 4ms/step - loss: 0.0247 
- acc: 0.9922 - val_loss: 0.9654 - val_acc: 0.8148 Epoch 11/15 
25000/25000 [==============================] - 99s 4ms/step - loss: 0.0169 
- acc: 0.9946 - val_loss: 1.0013 - val_acc: 0.8104 Epoch 12/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0154 
- acc: 0.9948 - val_loss: 1.0316 - val_acc: 0.8100 Epoch 13/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0113 
- acc: 0.9963 - val_loss: 1.1138 - val_acc: 0.8108 Epoch 14/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0106 
- acc: 0.9971 - val_loss: 1.0538 - val_acc: 0.8102 Epoch 15/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0090 
- acc: 0.9972 - val_loss: 1.1453 - val_acc: 0.8129 
25000/25000 [==============================] - 10s 390us/step

Langkah 7 - Evaluasi model

Mari kita evaluasi model menggunakan data uji.

score, acc = model.evaluate(x_test, y_test, batch_size = 32) 
   
print('Test score:', score) 
print('Test accuracy:', acc)

Menjalankan kode di atas akan menampilkan informasi di bawah ini -

Test score: 1.145306069601178 
Test accuracy: 0.81292

Keras - Aplikasi

Modul aplikasi Keras digunakan untuk menyediakan model terlatih untuk jaringan neural dalam. Model Keras digunakan untuk prediksi, ekstraksi fitur, dan penyempurnaan. Bab ini menjelaskan tentang aplikasi Keras secara detail.

Model terlatih

Model yang dilatihkan terdiri dari dua bagian model Arsitektur dan model Bobot. Bobot model adalah file yang besar sehingga kami harus mendownload dan mengekstrak fitur tersebut dari database ImageNet. Beberapa model terlatih yang populer tercantum di bawah ini,

ResNet
VGG16
MobileNet
InceptionResNetV2
InceptionV3

Memuat model

Model yang terlatih dengan keras dapat dengan mudah dimuat seperti yang ditentukan di bawah ini -

import keras 
import numpy as np 
from keras.applications import vgg16, inception_v3, resnet50, mobilenet 
#Load the VGG model 
vgg_model = vgg16.VGG16(weights = 'imagenet') 
#Load the Inception_V3 model 
inception_model = inception_v3.InceptionV3(weights = 'imagenet') 
#Load the ResNet50 model 
resnet_model = resnet50.ResNet50(weights = 'imagenet') 
#Load the MobileNet model mobilenet_model = mobilenet.MobileNet(weights = 'imagenet')

Setelah model dimuat, kita dapat langsung menggunakannya untuk tujuan prediksi. Mari kita periksa setiap model terlatih di bab-bab selanjutnya.

Prediksi Real Time menggunakan Model ResNet

ResNet adalah model terlatih. Ini dilatih menggunakan ImageNet . Bobot model ResNet telah dilatih sebelumnya di ImageNet . Ini memiliki sintaks berikut -

keras.applications.resnet.ResNet50 (
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

Sini,

include_top mengacu pada lapisan yang sepenuhnya terhubung di bagian atas jaringan.
weights lihat pra-pelatihan di ImageNet.
input_tensor merujuk tensor Keras opsional untuk digunakan sebagai masukan gambar untuk model.
input_shapemengacu pada tupel bentuk opsional. Ukuran masukan default untuk model ini adalah 224x224.
classes merujuk sejumlah kelas opsional untuk mengklasifikasikan gambar.

Mari kita pahami modelnya dengan menulis contoh sederhana -

Langkah 1: Impor modul

Mari kita memuat modul yang diperlukan seperti yang ditentukan di bawah ini -

>>> import PIL 
>>> from keras.preprocessing.image import load_img 
>>> from keras.preprocessing.image import img_to_array 
>>> from keras.applications.imagenet_utils import decode_predictions 
>>> import matplotlib.pyplot as plt 
>>> import numpy as np 
>>> from keras.applications.resnet50 import ResNet50 
>>> from keras.applications import resnet50

Langkah 2: Pilih masukan

Mari kita pilih gambar masukan, Lotus seperti yang ditentukan di bawah ini -

>>> filename = 'banana.jpg' 
>>> ## load an image in PIL format 
>>> original = load_img(filename, target_size = (224, 224)) 
>>> print('PIL image size',original.size)
PIL image size (224, 224) 
>>> plt.imshow(original) 
<matplotlib.image.AxesImage object at 0x1304756d8> 
>>> plt.show()

Di sini, kami telah memuat gambar (banana.jpg) dan menampilkannya.

Langkah 3: Ubah gambar menjadi array NumPy

Mari kita ubah masukan kita, Banana ke dalam array NumPy, sehingga dapat diteruskan ke model untuk tujuan prediksi.

>>> #convert the PIL image to a numpy array 
>>> numpy_image = img_to_array(original) 
>>> plt.imshow(np.uint8(numpy_image)) 
<matplotlib.image.AxesImage object at 0x130475ac8> 
>>> print('numpy array size',numpy_image.shape) 
numpy array size (224, 224, 3) 
>>> # Convert the image / images into batch format 
>>> image_batch = np.expand_dims(numpy_image, axis = 0) 
>>> print('image batch size', image_batch.shape) 
image batch size (1, 224, 224, 3)
>>>

Langkah 4: Prediksi model

Mari kita masukkan masukan kita ke dalam model untuk mendapatkan prediksi

>>> prepare the image for the resnet50 model >>> 
>>> processed_image = resnet50.preprocess_input(image_batch.copy()) 
>>> # create resnet model 
>>>resnet_model = resnet50.ResNet50(weights = 'imagenet') 
>>> Downloavding data from https://github.com/fchollet/deep-learning-models/releas
es/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5 
102858752/102853048 [==============================] - 33s 0us/step 
>>> # get the predicted probabilities for each class 
>>> predictions = resnet_model.predict(processed_image) 
>>> # convert the probabilities to class labels 
>>> label = decode_predictions(predictions) 
Downloading data from https://storage.googleapis.com/download.tensorflow.org/
data/imagenet_class_index.json 
40960/35363 [==================================] - 0s 0us/step 
>>> print(label)

Keluaran

[
   [
      ('n07753592', 'banana', 0.99229723), 
      ('n03532672', 'hook', 0.0014551596), 
      ('n03970156', 'plunger', 0.0010738898), 
      ('n07753113', 'fig', 0.0009359837) , 
      ('n03109150', 'corkscrew', 0.00028538404)
   ]
]

Di sini, model memprediksikan gambar sebagai pisang dengan benar.

Keras - Model yang Terlatih

Dalam bab ini, kita akan belajar tentang model terlatih di Keras. Mari kita mulai dengan VGG16.

VGG16

VGG16adalah model terlatih lainnya. Itu juga dilatih menggunakan ImageNet. Sintaks untuk memuat model adalah sebagai berikut -

keras.applications.vgg16.VGG16(
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

Ukuran masukan default untuk model ini adalah 224x224.

MobileNetV2

MobileNetV2adalah model terlatih lainnya. Itu juga terlatihImageNet.

Sintaks untuk memuat model adalah sebagai berikut -

keras.applications.mobilenet_v2.MobileNetV2 (
   input_shape = None, 
   alpha = 1.0, 
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   pooling = None, 
   classes = 1000
)

Sini,

alphamengontrol lebar jaringan. Jika nilainya di bawah 1, mengurangi jumlah filter di setiap lapisan. Jika nilainya di atas 1, tambah jumlah filter di setiap lapisan. Jika alpha = 1, jumlah default filter dari kertas digunakan di setiap lapisan.

Ukuran masukan default untuk model ini adalah 224x224.

InceptionResNetV2

InceptionResNetV2adalah model terlatih lainnya. Itu juga dilatih menggunakanImageNet. Sintaks untuk memuat model adalah sebagai berikut -

keras.applications.inception_resnet_v2.InceptionResNetV2 (
   include_top = True, 
   weights = 'imagenet',
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000)

Model ini dan dapat dibangun baik dengan format data 'channels_first' (saluran, tinggi, lebar) atau format data 'saluran_last' (tinggi, lebar, saluran).

Ukuran masukan default untuk model ini adalah 299x299.

InceptionV3

InceptionV3adalah model terlatih lainnya. Itu juga terlatihImageNet. Sintaks untuk memuat model adalah sebagai berikut -

keras.applications.inception_v3.InceptionV3 (
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

Sini,

Ukuran masukan default untuk model ini adalah 299x299.

Kesimpulan

Keras sangat sederhana, dapat diperluas, dan mudah diimplementasikan API jaringan neural, yang dapat digunakan untuk membangun aplikasi pembelajaran mendalam dengan abstraksi tingkat tinggi. Keras adalah pilihan optimal untuk model deep leaning.