INTERNET OF THINGS DAN KECERDASAN BUATANrepository.unas.ac.id/2269/1/buku pertama upload.pdf ·...
Transcript of INTERNET OF THINGS DAN KECERDASAN BUATANrepository.unas.ac.id/2269/1/buku pertama upload.pdf ·...
INTERNET OF THINGS DAN KECERDASAN BUATAN Pengenalan, Penerapan, dan Studi Kasus lndustri
NOVI AZMAN, S.T., M.T.
TAMPUNIAK MUSTIKA EDUKARYA 2019
Novi Azman, S.T., M.T.
INTERNET OF THINGS DAN KECERDASAN BUATAN: PENGENALAN, PENERAPAN, DAN STUDI KASUS
INDUSTRI
TAMPUNIAK MUSTIKA EDUKARYA
JAKARTA 2019
i
Perpustakaan Nasional : Katalog Dalam Terbitan (KDT)
NOVI AZMAN
Internet of Thinks dan Kecerdasan Buatan : Pengenalan, Penerapan,
dan Studi Kasus Industri / oleh Novi Azman.------
---Ed. 1., Cet.1 ---Jakarta : Desember, 2019
viii, 205 hlm., 21 cm
ISBN 978-602-60554-7-7
1. Internet of Thinks dan Kecerdasan Buatan I. Novi azman
Hak cipta 2019, pada penulis
Dilarang mengutip sebagian atau seluruh isi
buku ini dengan cara apapun, termasuk dengan cara
penggunaan mesin fotokopi, tanpa izin sah dari penerbit
NOVI AZMAN
INTERNET OF THINGS DAN KECERDASAN BUATAN: PENGENALAN, PENERAPAN, DAN
STUDI KASUS INDUSTRI
Hak penerbitan pada CV. Tampuniak Mustika Edukary
Jl. TB. Simatupang, Kav.38 Jakarta, Indonesia 12540
Telp : (021) 2791 2713, /Fax : (021) 2791 2778
Email : [email protected]
Disain Cover oleh Febryna Mulya
Dicetak di Pusat Kajian Pengembangan dan Pembangunan Indonesia Raya,
Jakarta, telp/fax : (021) 7804057/ 021-7804864
ii
KATA PENGANTAR
Peranan literatur bagi mahasiswa dalam mengenal, memahami, dan mempelajari bidang ilmu tertentu dipandang sangat penting. Akan tetapi sering kali berbagai literatur yang dibutuhkan oleh mahasiswa sangat sulit didapatkan untuk menunjang studinya. Akibat masih kurangnya referensi buku yang ditulis oleh para ahli maupun para praktisi yang berkecimpung dalam dunia pendidikan, riset, dan industri terlebih lagi referensi dengan Bahasa Indonesia.
Buku ini mengenai Internet of Things, suatu buzzword yang sangat sering kita dengar saat ini, ditambah dengan kecerdasan buatan serta turunannya yang mana dalam hal ini kecerdasan buatan diperuntukkan untuk Internet of Things.
Buku ini akan membahas mulai dari apa itu Internet of Things, hubungannya dengan big data, bagaimana mengakses set data yang digunakan untuk belajar, kemudian membahas tentag pembelajaran mesin yang merupakan bagian dari kecerdasan buatan, pembahasan metode yang digunakan untuk regresi dan klasifikasi, mendalami tentang deep nerural network dan mengaplikasikannya menggunakan TensorFlow, serta tidak lupa mempelajari kegunaannya dalam bidang Industri saat ini untuk mencapai Industri 4.0.
Saran dari semua pihak sangat kami harapkan demi menyempurnakan substansi buku ini. Akhirnya semoga Allah SWT melimpahkan taufik dan hidayah-Nya kepada kita semua, aamiin.
Jakarta, Desember 2019
Novi Azman, S.T., M.T.
iii
DAFTAR ISI
KATA PENGANTAR...................................................................................... ii
DAFTAR ISI ................................................................................................... iii
Bagian 1: Mengenal Internet of Things dan Kecerdasan Buatan ..................... 1
1.1. Apa itu Internet of Things? ............................................................ 1
1.1.1. Referensi model IoT ............................................................... 5
1.1.2. Platform IoT ............................................................................ 7
1.1.3. Vertikal IoT ............................................................................. 8
1.2. Big data dan IoT ........................................................................... 10
1.3. Kecerdasan buatan dalam IoT ..................................................... 13
1.3.1. Proses standar lintas industri untuk data mining ................ 14
1.3.2. Platform IoT dan Kecerdasan Buatan ................................... 18
1.4. Alat yang digunakan dalam buku ini ........................................... 21
1.4.1. TensorFlow ........................................................................... 21
1.4.2. Keras ..................................................................................... 24
1.4.3. Datasets ................................................................................ 25
1.4.4. Dataset pembangkit listrik siklus gabungan ........................ 25
1.4.5. Data kualitas udara ............................................................... 26
1.5. Kesimpulan .................................................................................. 27
Bagian 2: Mengakses Data dan Proses DIstribusi pada IoT............................ 29
2.1. Format TXT .................................................................................. 29
2.1.1. Menggunakan berkas TXT di Python .................................... 30
2.2. Format CSV .................................................................................. 32
2.2.1. Bekerja dengan berkas CSV menggunakan modul csv ......... 33
2.2.2. Bekerja dengan berkas CSV dengan modul pandas ............. 38
iv
2.2.3. Bekerja dengan berkas CSV menggunakan modul NumPy .. 40
2.3. Format XSLX ................................................................................. 41
2.3.1. Menggunakan pandas dengan berkas XLSX ......................... 42
2.4. Bekerja dengan format JSON ...................................................... 42
2.4.1. Menggunakan berkas JSON dengan modul JSON ................ 43
2.4.2. Berkas JSON dengan modul pandas ..................................... 44
2.5. Format HDF5................................................................................ 45
2.5.1. Menggunakan HDF5 dengan PyTables ................................. 46
2.5.2. Menggunakan HDF5 dengan pandas ................................... 47
2.5.3. Menggunakan HDF5 dengan h5py ....................................... 49
2.6. HDFS ............................................................................................ 51
2.6.1. Menggunakan hdfs3 untuk format HDFS ............................. 53
2.7. Kesimpulan .................................................................................. 54
Bagian 3: Machine Learning untuk IoT ........................................................... 55
3.1. Machine Learning dan Internet of Things ................................... 56
3.2. Paradigma belajar ........................................................................ 57
3.3. Prediksi menggunakan regresi linier ........................................... 59
3.3.1. Prediksi keluaran daya listrik menggunakan regresi ............ 62
3.4. Regresi linier untuk klasifikasi ..................................................... 67
3.4.1. Fungsi loss cross-entropy ..................................................... 69
3.5. Klasifikasi menggunakan Support Vector Machine ..................... 71
3.5.1. Margin maksimum hyperplane ............................................ 72
3.5.2. Trik kernel ............................................................................. 74
3.6. Naive Bayes ................................................................................. 75
3.7. Decision trees .............................................................................. 77
3.7.1. Decision trees di scikit .......................................................... 80
3.7.2. Studi kasus dengan decision trees ........................................ 82
3.8. Ensemble learning ....................................................................... 85
v
3.8.1. Voting classifier .................................................................... 86
3.8.2. Baggingdan Pasting .............................................................. 87
3.9. Penskalaan fitur untuk menyelesaikan data yang tidak merata . 89
3.10. Overfitting.................................................................................... 90
3.10.1. Regularization ....................................................................... 91
3.10.2. Cross-validation .................................................................... 92
3.11. Teorema No Free Lunch ............................................................... 93
3.12. Hyperparameter tuning dan grid search ..................................... 93
3.13. Kesimpulan .................................................................................. 95
Bagian 4: Deep Learning untuk IoT ................................................................ 96
4.1. Selayang pandang tentang Deep Learning .................................. 97
4.1.1. Deep Learning, kenapa baru sekarang? ............................... 99
4.1.2. Artificial neuron .................................................................. 101
4.1.3. Memodelkan neuron tunggal dalam TensorFlow .............. 111
4.2. Multilayered preceptrons untuk regresi dan klasifikasi ............ 121
4.2.1. Algoritma backrpopagation ............................................... 125
4.2.2. Prediksi keluaran energi menggunakan MLP di TensorFlow ............................................................................................ 127
4.3. Convolutional neural networks .................................................. 133
4.3.1. Lapisan CNN yang berbeda ................................................ 134
4.3.2. Lapisan convolution............................................................ 134
4.3.3. Lapisan pooling ................................................................... 136
4.3.4. Beberapa model CNN yang populer ................................... 138
4.3.5. LeNet untuk mengenali angka tulisan tangan.................... 140
4.4. Recurrent neural networks ........................................................ 153
4.4.1. Long short-term memory ................................................... 157
4.4.2. Gated recurrent unit .......................................................... 165
4.5. Autoencoders ............................................................................. 166
vi
4.5.1. Denoisingautoencoders ...................................................... 168
4.5.2. Variational autoencoders ................................................... 169
4.6. Kesimpulan ................................................................................ 170
Bagian 5: Kecerdasan buatan untuk IoT di Industri ..................................... 171
5.1. Pengenalan IoT Industri dengan Kecerdasan Buatan ................ 172
5.1.1. Beberapa kasus penggunaan yang menarik ....................... 175
5.2. Pemeliharan prediktif menggunakan kecerdasan buatan ........ 177
5.2.1. Pemeliharan prediktif menggunakan Long Short-Term Memory .............................................................................. 180
5.2.2. Keuntungan dan kerugian pemeliharaan prediktif ............ 201
5.3. Prakiraan beban listrik di industri ............................................. 202
5.4. Kesimpulan ................................................................................ 203
Daftar Pustaka .............................................................................................. 204
Biodata .............................................................. Error! Bookmark not defined.
1
1. Bagian 1: Mengenal Internet of Things dan
Kecerdasan Buatan
1.1. Apa itu Internet of Things?
Pada tahun 1999, Kevin Asthon menciptakan istilah Internet of
Things (IoT) atau Internet untuk Segala. Saat itu, sebagian besar data yang
dikirimkan ke komputer dihasilkan oleh manusia, maka Kevin Ashton
mengusulkan cara yang terbaik bagi komputer untuk mengambil data secara
langsung, tanpa campur tangan dari manusia. Jadi dia mengusulkan
perangkat seperti RFID dan sensor, yang mana mengumpulkan data harus
terhubung ke jaringan, dan memberi data langsung ke komputer.
Saat ini IoT (juga disebut internet untuk segala dan terkadang
disebut fog network) mengacu pada berbagai hal seperti sensor, aktuator,
dan ponsel cerdas yang terhubung ke internet. Hal-hal ini bisa apa saja,
seperti orang dengan perangkat yang dapat dikenakan (atau bahkan ponsel),
hewan yang terpasang penanda RFID, atau bahkan perangkat sehari-hari
kita seperti lemari es, mesin cuci, atau bahkan mesin kopi. Hal-hal ini dapat
berupa benda fisik maksudnya hal-hal yang ada di dunia fisik dan dapat
dirasakan, digerakkan, dan terhubung atau dari dunia informasi (benda
virtual) seperti benda yang tidak ada secara nyata tetapi ada sebagai
informasi (data) dan dapat disimpan, diproses, dan diakses. Hal-hal ini tentu
memiliki kemampuan berkomunikasi langsung dengan jaringan interkoneksi,
2
mereka mungkin memiliki potensi dalam pengindraan, pengaktifan,
pengambilan, penyimpanan, dan pengolahan data.
Salah satu badan dari Persatuan Bangsa-Bangsa, International
Telecomunication Union (ITU) mendefinisikan Internet of Things sebagai,
“infrastruktur global untuk masyarakat informasi, memungkinkan
layanan lanjutan dengan menghubungkan hal-hal (fisik dan virtual)
berdasarkan teknologi informasi dan komunikasi yang ada dan
berkembang yang dapat dioperasikan”
Aplikasi yang luas dari Teknologi Informasi dan Komunikasi telah
memberikan kita dapat berkomunikasi di mana saja dan kapan saja, Internet
of Things menambahkan dimensi baru dari “komunikasi APA PUN”.
3
Gambar 1. Dimensi baru yang dikenalkan oleh IoT (diadaptasi dari laporan ITU)
Diprediksikan bahwa IoT sebagai teknologi akan berdampak luas bagi
masyarakat tempat kita tinggal. Maka untuk memberi Anda gambaran
tentang jangkauannya yang berefek luas, bayangkan skenario berikut ini:
Anda tinggal di gedung bertingkat dan sangat menyukai tanaman.
Dengan banyak usaha dan perawatan, Anda telah membuat taman dalam
ruangan kecil Anda sendiri menggunakan pot. Atasan Anda meminta Anda
untuk melakukan perjalanan selama seminggu, dan Anda khawatir tanaman
Anda tidak akan bertahan selama seminggu tanpa air.
4
Solusi IoT adalah dengan menambahkan sensor kelembaban tanah
ke tanaman Anda, menghubungkan sensor ke internet, dan menambahkan
aktuator untuk mengaktifkan atau menonaktifkan dari jarak jauhpasokan air
dan sinar matahari buatan. Sekarang, Anda bisa berada di mana saja di
dunia, tetapi tanaman Anda tidak akan mati, dan Anda dapat memeriksa
kondisi kelembaban tanah tanaman dan menyiram tanaman sesuai
kebutuhan.
Skenario lain misalnya Anda mengalami hari yang sangat melelahkan
di kantor, Anda hanya ingin pulang ke rumah dan meminta seseorang
membuatkan kopi untuk Anda, menyiapkan tempat tidur Anda, dan
memanaskan airmandi, tapi sayangnya Anda sendirian di rumah. Maka itu
tidak mungkin semuanya telah tersiapkan ketika Anda pulang ke rumah
Tetapi tidak lagi, IoT dapat membantu anda. Asisten rumah yang
mendukung IoT dapat menyiapkan kopi dengan rasa yang tepat darimesin
kopi, pesan pemanas air pintar Anda untuk menyala danpertahankan suhu
air untuk mandi persis seperti yang Anda inginkan, dan melakukan
pengendalian AC pintar untuk menyalakan dan mendinginkan ruangan
secara otomatis.
Pilihannya hanya dibatasi oleh imajinasi Anda. Dua skenario
sebelumnya sesuai dengan konsep IoT konsumen. IoT dengan fokus pada
aplikasi yang berorientasi pada kebutuhan konsumen. Ada juga cakupan
besar, yakni IoT Industri/Industrial Internet of Things (IIoT) di mana
produsen dan industri mengoptimalkan proses dan mengimplementasikan
5
kemampuan pemantauan jarak jauh untuk meningkatkan produktivitas dan
efisiensi.
1.1.1. Referensi model IoT
Sama seperti model referensi OSI untuk internet, arsitektur IoT
didefinisikan melalui enam lapisan: empat lapisan horizontal dan dua lapisan
vertikal. Dua lapisan vertikal adalah Manajemen dan Keamanan dan
tersebar di keempat lapisan horizontal, seperti yang terlihat pada diagram
pada Gambar 2.
Lapisan Perangkat: Di bagian tumpukan paling bawah, kita memiliki
lapisan perangkat, juga disebut lapisan persepsi. Lapisan ini berisi hal-hal
fisik yang diperlukan untuk merasakan atau mengontrol dunia fisik dan
memperoleh data. Perangkat keras pada lapisan ini adalah seperti sensor,
RFID, dan aktuator, merupakan lapisan persepsi.
Lapisan Jaringan: Lapisan ini menyediakan dukungan jaringan dan
transfer data melalui jaringan kabel atau nirkabel. Lapisan tersebut secara
aman mentransmisikan informasi dari perangkat di lapisan perangkat ke
sistem pemrosesan informasi. Baik Media transmisi dan Teknologi adalah
bagian dari lapisan jaringan. Contohnya termasuk 3G, UMTS, ZigBee,
Bluetooth, Wi-Fi, dan sebagainya.
6
Gambar 2. Dimensi baru yang dikenalkan oleh IoT (diadaptasi dari laporan ITU)
Lapisan Layanan: Lapisan ini bertanggung jawab atas manajemen
layanan. Lapisan ini menerima informasi dari lapisan jaringan,
menyimpannya ke dalam basis data, memproses informasi tersebut, dan
dapat membuat keputusan otomatis berdasarkan hasil.
Lapisan Aplikasi: Lapisan ini mengelola aplikasi yang bergantung
pada informasi yang diproses di lapisan layanan. Ada berbagai macam
7
aplikasi yang dapat diterapkan oleh IoT: kota pintar, pertanian pintar, dan
rumah pintar.
1.1.2. Platform IoT
Informasi dari lapisan jaringan sering kali dikelola dengan bantuan
platform IoT. Banyak perusahaan saat ini menyediakan layanan platform
IoT, di mana mereka membantu tidak hanya dengan data tetapi juga
memungkinkan integrasi tanpa batas dengan perangkat keras yang berbeda.
Karena berfungsi sebagai mediator antara perangkat keras dan lapisan
aplikasi, platform IoT juga disebut sebagai IoTmiddleware dan merupakan
bagian dari lapisan layanan dalam tumpukan referensi IoT. Platform IoT
memberikan kemampuan untuk terhubung dan berkomunikasi dengan
berbagai hal dari mana saja di dunia. Beberapa contoh platform IoT populer
seperti Google Cloud Platform, Azure IoT, Amazon AWS IoT, Predix, dan
H2O.
Anda dapat memilih platform IoT mana yang terbaik untuk Anda
berdasarkan kriteria berikut:
• Skalabilitas: Penambahan dan penghapusan perangkat baru
ke jaringan IoT yang ada seharusnya dapat dilakukan
• Kemudahan penggunaan: Sistem harus bekerja dengan
sempurna dan memberikan semua spesifikasinya dengan
intervensi minimum
8
• Integrasi pihak ketiga: Perangkat dan protokol heterogen
harus dapat saling terhubung satu sama lain
• Opsi penyebaran: Ini harus bisa diterapkan pada berbagai
perangkat keras dan platform perangkat lunak
• Keamanan data: Keamanan data dan perangkat terjamin.
1.1.3. Vertikal IoT
Pasar vertikal adalah pasar tempat vendor menawarkan barang dan
jasa khusus untuk industri, perdagangan, profesi, atau kelompok pelanggan
lain dengan kebutuhan khusus. IoT memungkinkan kemungkinan banyak
pasar vertikal semacam itu, dan beberapa pasar vertikal IoT teratas adalah
sebagai berikut:
• Bangunan pintar: Bangunan dengan teknologi IoT dapat
membantu tidak hanya mengurangi konsumsi sumber daya
tetapi juga meningkatkan kepuasan manusia yang tinggal
atau bekerja di dalamnya. Gedung-gedung tersebut memiliki
sensor pintar yang tidak hanya memantau konsumsi sumber
daya tetapi juga secara proaktif dapat mendeteksi kebutuhan
penghuni. Data dikumpulkan melalui perangkat pintar dan
sensor ini untuk memantau bangunan, energi, keamanan,
lanskap, HVAC, pencahayaan, dan sebagainya dari jarak jauh.
Data tersebut kemudian digunakan untuk memprediksi
tindakan, yang dapat diotomatiskan sesuai dengan kejadian
9
dan karenanya efisiensi dapat dioptimalkan, menghemat
waktu, sumber daya, dan biaya.
• Pertanian cerdas: IoT dapat memungkinkan pertanian lokal
dan komersial menjadi lebih ramah lingkungan, hemat biaya,
dan efisien produksi. Sensor yang ditempatkan pada bidang
pertanian dapat membantu mengotomatiskan proses irigasi.
Diperkirakan bahwa praktik pertanian cerdas akan
memungkinkan peningkatan produktivitas yang berlipat
ganda, dan karenanya juga sumber makanan.
• Smart city: Smart city bisa menjadi kota yang memiliki parkir
cerdas, sistem moda raya pintar dan lain sebagainya. Kota
pintar memiliki kemampuan untuk menangani lalu lintas,
keselamatan publik, manajemen energi, dan lainnya untuk
pemerintah dan warganya. Dengan menggunakan teknologi
IoT yang canggih, dapat mengoptimalkan penggunaan
infrastruktur kota dan kualitas hidup warganya.
• Perawatan kesehatan yang terhubung: IoT memungkinkan
keputusan penting untuk bisnis dan pemantauan pasien
dibuat dari jarak jauh dan secara real time. Individu
membawa sensor medis untuk memantau parameter tubuh
seperti detak jantung, suhu tubuh, kadar glukosa, dan
sebagainya. Sensor yang dapat dikenakan, seperti
akselerometer dan giroskop, dapat digunakan untuk
memantau aktivitas sehari-hari seseorang.
10
1.2. Big data dan IoT
IoT telah menghubungkan hal-hal yang sebelumnya tidak pernah
terhubung ke internet, seperti mesin mobil, menghasilkan aliran data
berkelanjutan dalam jumlah besar. Gambar 3 menunjukkan data eksploratif
oleh IHS dari jumlah perangkat yang terhubung akan berjumlah miliaran
perangkat pada beberapa tahun mendatang. Perkiraan mereka
menunjukkan bahwa jumlah perangkat IoT akan mencapai 75,44 miliar pada
tahun 2025.
Gambar 3. Prediksi pasar IoT akan masif
Pengurangan biaya sensor, teknik konsumsi daya yang efisien,
berbagai konektivitas (inframerah, NFC, Bluetooth, Wi-Fi, dan sebagainya),
dan ketersediaan platform cloud yang mendukung penyebaran dan
pengembangan IoT adalah alasan utama untuk penyebaran IoT di rumah,
kehidupan pribadi, dan industri kita. Hal ini juga memotivasi perusahaan
11
untuk berpikir tentang menyediakan layanan baru dan mengembangkan
model bisnis baru. Beberapa contohnya adalah sebagai berikut:
• Airbnb: Ini menghubungkan orang-orang sehingga mereka
dapat menyewakan kamar cadangan dan cottage satu sama
lain, dan mendapatkan komisi.
• Uber: Ini menghubungkan pengemudi taksi dengan
pelancong. Lokasi pelancong digunakan untuk menetapkan
mereka ke pengemudi terdekat.
Jumlah data yang dihasilkan dalam proses tersebut sangat banyak
dan kompleks, sehingga membutuhkan data yang besar. Pendekatan big
data dan IoT hampir dibuat untuk satu sama lain; keduanya bekerja
bersamaan.
Sesuatu yang terus menghasilkan sejumlah besar aliran data dengan
memberikan statusnya seperti suhu, tingkat polusi, geolokasi, dan
kedekatan. Data yang dihasilkan dalam format deret waktu dan terkait
secara otomatis. Tugas menjadi menantang karena datanya bersifat
dinamis. Selain itu, data yang dihasilkan dapat dianalisis di hilir (sensor atau
gateway) atau cloud. Sebelum mengirimkan data ke cloud, beberapa bentuk
transformasi data IoT dilakukan. Ini mungkin melibatkan hal-hal berikut:
• Analisis temporal atau spasial
• Meringkas data di tepi
• Agregasi data
• Mengorelasikan data di beberapa aliran IoT
12
• Membersihkan data
• Mengisi nilai yang hilang
• Normalisasi data
• Mengubahnya menjadi format berbeda yang dapat diterima
di cloud
Di hilir, pemrosesan peristiwa kompleks atau complex event
processing (CEP) digunakan untuk menggabungkan data dari berbagai
sumber dan menyimpulkan peristiwa atau pola.
Data dianalisis menggunakan analisis aliran, misalnya, menerapkan
alat analitik ke aliran data, tetapi mengembangkan wawasan dan aturan
yang digunakan secara eksternal dalam mode luring. Model ini dibangun
secara luring dan kemudian diterapkan pada aliran data yang dihasilkan.
Data dapat ditangani dengan cara yang berbeda:
• Atom: Data tunggal pada satu waktu digunakan
• Pengelompokan mikro: Grup data per batch
• Windowing: Data dalam jangka waktu per batch
Analisis aliran dapat digabungkan dengan CEP untuk menggabungkan
peristiwa selama jangka waktu tertentu dan mengkorelasikan pola untuk
mendeteksi pola khusus (misalnya, anomali atau kegagalan)
13
1.3. Kecerdasan buatan dalam IoT
Ungkapan yang sangat populer di kalangan ilmuwan data dan
insinyur pembelajaran mesin (machine learning) adalah "AI is the new
electricity” atau kecerdasan buatan merupakan sumber daya baru kata Prof
Andrew Ng dalam NIPS 2017, kita dapat mengembangkannya sebagai
berikut: Jika Kecerdasan buatan atau Artificial Intelligent (AI) adalah listrik
baru, data adalah batu bara baru, dan IoT tambang batu bara baru.
Gambar 4.Ruang lingkup kecerdasan buatan dan turunannya
14
IoT menghasilkan sejumlah besar data.Saat ini, 90% dari data yang
dihasilkan bahkan tidak ditangkap, dan dari 10% yang ditangkap, sebagian
besar bergantung pada waktu dan kehilangan nilainya dalam milidetik.
Memantau data ini secara manual secara terus-menerus akan merepotkan
dan mahal. Ini memerlukan cara untuk menganalisis dan mendapatkan
wawasan dari data ini secara cerdas; alat dan model AI memberi kita cara
untuk melakukan hal ini dengan intervensi manusia yang minimal.
Dengan mengamati perilaku berbagai hal, IoT (dengan bantuan big
data dan AI) bertujuan untuk mendapatkan wawasan tentang data dan
mengoptimalkan proses yang mendasarinya. Ini melibatkan banyak
tantangan:
• Menyimpan acara yang dihasilkan secara waktu nyata
• Menjalankan kueri analitik atas acara yang disimpan
• Melakukan analitik menggunakan teknik AI / ML / DL atas
data untuk mendapatkan wawasan dan membuat prediksi
1.3.1. Proses standar lintas industri untuk data mining
Untuk masalah IoT, metodologi pengelolaan data atau data
management (DM) yang paling banyak digunakan adalah proses standar
lintas industri untuk data mining atau dengan istilah cross-industry standard
process for data mining (CRISP-DM) yang dikemukakan oleh Chapman et al.
Ini adalah model proses yang menyatakan tugas-tugas yang perlu dilakukan
agar berhasil menyelesaikan pengelolaan data atau data management. Ini
15
adalah metodologi independen vendor yang dibagi menjadi enam fase
berbeda ini:
1. Pemahaman bisnis
2. Pemahaman data
3. Persiapan data
4. Pemodelan
5. Evaluasi
6. Penerapan
Diagram pada Gambar 5 menunjukkan tahapan dalam istilah cross-
industry standard process for data mining(CRISP-DM).
16
Gambar 5. Tahapan dalam istilah cross-industry standard process for data mining (CRISP-
DM)
Berikut Ini adalah garis besar tahapancross-industry standard process
for data mining (CRISP-DM):
1. Pemahaman bisnis melibatkan pemahaman tujuan, membuat
rencana proyek dan menentukan metrik kinerja.
2. Pemahaman data meliputi pengumpulan data, eksplorasi data serta
memastikan bahwa kita memiliki data yang berkualitas.
3. Penyusunan data inilah yang kita sebut dengan pra-proses.
17
4. Pemodelan. Setelah data diproses sebelumnya dalam format yang
sesuai untuk tugas pembelajaran mesin, data tersebut digunakan
untuk melatih model dan menyesuaikan parameter. Fase ini juga
dapat mencakup penilaian model oleh pakar domain bisnis tersebut.
5. Evaluasi mengkaji model sesuai dengan tujuan bisnis. Misalnya, kita
mungkin memahami bahwa model tersebut tidak mencakup
beberapa kasus hilit dan kita perlu mengumpulkan data tambahan
untuk menyelidiki lebih lanjut.
6. Penerapan menyajikan hasil dalam format yang nyaman dan dapat
diakses oleh pengguna.
Kita dapat mengelompokkan pra-proses data menjadi dua langkah,
pembersihan data dan rekayasa fitur. Yang pertama mengubah data mentah
menjadi data yang konsisten dan dilakukan hanya sekali. Terakhir,
mengubah data yang konsisten ke dalam format tertentu untuk setiap
metode pembelajaran mesin. Jadi jika kita akan menerapkan lima metode
berbeda, maka kita perlu melakukan lima pipeline rekayasa fitur yang
berbeda.
Seperti yang bisa kita lihat, ini adalah model proses berkelanjutan
dengan ilmu data dan AI yang memainkan peran penting dalam langkah 2–5.
18
1.3.2. Platform IoT dan Kecerdasan Buatan
Sejumlah besar platform komputasi awan atau cloud dengan
kemampuan AI dan IoT sudah tersedia saat ini. Platform ini memberikan
kemampuan untuk mengintegrasikan sensor dan perangkat serta melakukan
analitik di komputasi awan. Ada lebih dari 30 platform cloud di pasar global,
masing-masing menargetkan vertikal dan layanan IoT yang berbeda. Gambar
6 menggambarkan berbagai layanan yang didukung platform AI / IoT.
Berikut ini adalah daftar dari beberapa platform komputasi awan yang
populer:
• Platform IBM Watson IoT: Diselenggarakan oleh perusahaan
IBM, platform ini menyediakan manajemen
perangkatmenggunakan protokol MQTT untuk terhubung
dengan perangkat dan aplikasi IoT. Ini menyediakan
konektivitas terukur waktu nyata. Data tersebut dapat
disimpan dalam jangka waktu tertentu dan diakses secara
real time. IBM Watson juga menyediakan Bluemix Platform-
as-a-Service (PaaS) untuk analitik dan visualisasi. Kita dapat
menulis kode untuk membangun dan mengelola aplikasi yang
berinteraksi dengan data dan perangkat yang terhubung. IBM
Watson mendukung bahasa Python bersama dengan C #,
Java, dan Node.js.
19
Gambar 6. Layanan yang didukung oleh AI/IoT cloud platfrom
• Microsoft IoT-Azure IoT suite: Layanan ini menyediakan
kumpulan solusi yang telah dikonfigurasi sebelumnya yang
dibangun di Azure PaaS. Ini memungkinkan komunikasi dua
arah yang andal dan aman antara perangkat IoT dan cloud.
Solusi yang telah dikonfigurasi sebelumnya mencakup
visualisasi data, pemantauan jarak jauh, dan mengonfigurasi
20
aturan dan alarm melalui telemetri IoT langsung. Ini juga
menyediakan Azure Stream Analytics untuk memproses data
secara real time. Azure Stream Analytics memungkinkan kita
menggunakan Visual Studio. Layanan ini mendukung bahasa
Python, Node.js, C, dan Arduino, serta tergantung pada
perangkat IoT.
• Google Cloud IoT: Google Cloud IoT menyediakan layanan
terkelola sepenuhnya untuk menghubungkan dan mengelola
perangkat IoT dengan aman. Layanan ini mendukung
protokol MQTT dan HTTP. Layanan ini juga menyediakan
komunikasi dua arah antara perangkat IoT dan cloud. Ini
memberikan dukungan bahasa untuk Go, PHP, Ruby, JS, .NET,
Java, Objective-C, dan Python. Serta layanan ini juga memiliki
BigQuery, yang memungkinkan pengguna untuk melakukan
analisis dan visualisasi data.
• Amazon AWS IoT: Amazon AWS IoT memungkinkan
perangkat IoT berkomunikasi melalui MQTT, HTTP, dan
WebSockets. Ini menyediakan komunikasi dua arah yang
aman antara perangkat IoT dan cloud. Ini juga memiliki mesin
aturan yang dapat digunakan untuk mengintegrasikan data
dengan layanan AWS lain dan mengubah data. Aturan dapat
ditentukan yang memicu eksekusi kode pengguna dengan
bahasa Java, Python, atau Node.js. AWS Lambda
memungkinkan kita menggunakan model terlatih khusus kita
sendiri.
21
1.4. Alat yang digunakan dalam buku ini
Untuk implementasi layanan berbasis IoT, kita perlu mengikuti
pendekatan secara bottom-up, yakni dari bawah ke atas. Untuk setiap
vertikal IoT, kita perlu menemukan analitik dan data dan, akhirnya,
menerapkannya dalam kode.
Karena ketersediaannya di hampir semua platform AI dan IoT,
Python akan digunakan untuk bahasa pengkodean dalam buku ini. Bersama
dengan Python, beberapa pustaka bantuan seperti NumPy, pandas, SciPy,
Keras, dan TensorFlow akan digunakan untuk melakukan analisis AI/ML
pada data. Untuk visualisasi, kita akan menggunakan Matplotlib dan
Seaborn.
1.4.1. TensorFlow
TensorFlow adalah pustaka perangkat lunak sumber terbuka yang
dikembangkan oleh tim Google Brain. TensorFlow memiliki fungsi dan API
untuk mengimplementasikan jaringan syaraf dalam atau deep neural
network. TensorFlow bekerja dengan bahasa Python, C ++, Java, R, dan Go.
TensorFlow dapat digunakan untuk bekerja di berbagai platform, CPU, GPU,
seluler, dan bahkan didistribusikan. TensorFlow memungkinkan penerapan
model dan kemudahan penggunaan dalam produksi. Pengoptimalan di
TensorFlow mempermudah tugas melatih jaringan syaraf dalam dengan
menghitung gradien secara otomatis dan menerapkannya untuk
memperbarui bobot dan bias.
22
Di TensorFlow, program memiliki dua komponen berbeda:
• Grafik komputasi adalah jaringan node dan edge. Di sini
semua data, variabel, placeholder, dan perhitungan yang
akan dilakukan ditentukan. TensorFlow mendukung tiga jenis
objek data: konstanta, variabel, dan placeholder.
• Grafik eksekusi sebenarnya menghitung jaringan
menggunakan objek Sesi. Penghitungan aktual dan transfer
informasi dari satu lapisan ke lapisan lainnya terjadi di objek
Session.
Mari kita lihat kode untuk melakukan perkalian matriks di
TensorFlow. Misalnya kita ingin melakukan perkalian matriks mat1 dan
mat2.Maka Langkah pertama adalah melakukan impor pustaka TensorFlow
dan NumPy.
import tensorflow as tf
import numpy as numpy
# matriks acak dengan ukuran [3,5]
mat1 = np.random.rand(3,5)
# matriks acak dengan ukuran [5,2]
mat2 = np.random.rand(5,2)
23
Kita mendeklarasikan dua placeholder, A dan B, sehingga kita dapat
meneruskan nilainya saat runtime. Dalam grafik komputasi, kita
mendeklarasikan semua data dan objek komputasi.
# Deklarasi placeholders untuk dua matriks
A = tf.placeholder(tf.float32, None, name=’A’)
B = tf.placeholder(tf.float32, None, name=’B’)
Ini mendeklarasikan dua placeholder dengan nama A dan B, kemudian
argumen ke metode tf.placeholder menentukan bahwa placeholder adalah
tipe data float32. Karena bentuk yang ditentukan adalah None, kita dapat
memberinya tensor bentuk apa pun dan nama opsional untuk operasi
tersebut. Selanjutnya, kita mendefinisikan operasi yang akan dilakukan
menggunakan metode perkalian matriks, tf.matmul.
C = tf.matmul(A,B)
Grafik eksekusi dideklarasikan sebagai objek Session, yang diberi
makan dua matriks, mat1 dan mat2, untuk placeholder, A dan B, masing-masing
menjadi.
With tf.Session() as sess:
result = sess.run(C, feed_dict={A: mat1, B:mat2})
print(result)
24
1.4.2. Keras
Keras adalah API tingkat tinggi yang berjalan di atas pustaka
TensorFlow. Ini memungkinkan pembuatan purwarupa yang cepat dan
mudah. Ini mendukung jaringan saraf konvolusional dan berulang, dan
bahkan kombinasi keduanya. Ini dapat berjalan di CPU dan GPU. Kode
berikut melakukan perkalian matriks menggunakan Keras.
# Impor pustaka Keras
import keras.backend as K
import numpy as np
# Deklarasi data
A = np.random.rand(20,500)
B = np.random.rand(500,3000)
# Membuat variabel
x = K.variable(value=A)
y = K.variable(value=B)
z = K.dot(x,y)
print(K.eval(z))
25
1.4.3. Datasets
Dalam bab-bab selanjutnya, kita akan mempelajari berbagai model
Deep Learning dan metode Machine Learning. Mereka semua bekerja pada
data. Meskipun sejumlah besar kumpulan data tersedia untuk
mendemonstrasikan cara kerja model-model ini, dalam buku ini, kita akan
menggunakan kumpulan data yang tersedia secara gratis melalui sensor
nirkabel dan perangkat IoT lainnya. Berikut adalah beberapa set data yang
digunakan dalam buku ini beserta sumbernya.
1.4.4. Dataset pembangkit listrik siklus gabungan
Datasetatau set data ini berisi 9.568 titik data yang dikumpulkan dari
pembangkit listrik siklus gabungan atau combined cycle power plant (CCPP)
selama enam tahun (2006-2011). CCPP menggunakan dua turbin untuk
menghasilkan tenaga, turbin gas dan turbin uap. Ada tiga komponen utama
dari pembangkit CCPP: turbin gas, sistem pemulihan panas, dan turbin uap.
Set data dikumpulkan oleh Pinar Tufekci dari Universitas Namik
Kemal dan Heysem Kaya dari Universitas Bogazici.Set data ini tersedia di
situs University of California, Irvine, di pusat Machine Learning
(http://archive.Ics.uci.edu/ml/datasets/combined+cycle+power+plant).
Data terdiri dari empat fitur yang menentukan variabel ambien rata-
rata. Rata-rata diambil dari berbagai sensor yang terletak di sekitar pabrik
yang merekam variabel ambien per detik. Tujuannya adalah untuk
26
memprediksi keluaran energi listrik bersih per jam. Data tersedia dalam
format xls dan ods. Fitur-fitur dalam dataset tersebut adalah sebagai
berikut:
• Ambient Temperature (AT) berada pada kisaran 1.81 ° C dan
37.11 ° C
• Ambient Pressure (AP) berada pada kisaran 992,89—1033,30
milibar
• Kelembaban Relatif/Relative Humidity (RH) berada pada
kisaran 25,56% hingga 100,16%
• Exhaust Vacuum (V) berada pada kisaran 25,36 hingga 81,56
cm Hg
• Output energi listrik (PE) bersih per jam berada pada kisaran
420,26 hingga 495,76 MW
1.4.5. Data kualitas udara
Polusi udara menimbulkan risiko lingkungan yang besar bagi
kesehatan manusia. Ditemukan bahwa terdapat korelasi antara peningkatan
kualitas udara dan perbaikan berbagai masalah kesehatan seperti infeksi
saluran pernapasan, penyakit kardiovaskular, dan kanker paru-paru.
Jaringan sensor yang luas di seluruh dunia oleh Organisasi Meteorologi di
masing-masing negara memberi kita data kualitas udara waktu nyata. Data
ini dapat diakses melalui API web masing-masing organisasi ini.
27
Dalam buku ini, kita akan menggunakan data kualitas udara historis
untuk melatih jaringan kita dan memprediksi tingkat kematian. Set data
historis untuk kualitas udara di Inggris tersedia secara bebas di situs Kaggle
(https://www.kaggle.com/c/predict-impact-of-air-quality-on-death-
rates), dan data kualitas udara terdiri dari sarana harian ozon (O3),
Nitrogen dioksida (NO2), materi partikulat dengan diameter kurang dari
atau sama dengan 10 mikrometer (PM10) dan PM25 (2,5 mikrometer atau
kurang), dan suhu. Angka kematian (jumlah kematian per 100.000 orang)
untuk wilayah Inggris diperoleh dari data yang disediakan oleh Kantor
Statistik Nasional Inggris.
1.5. Kesimpulan
Pada bab ini kita telah mempelajari tentang IoT, big data, dan
kecerdasan buatan. Bab ini memperkenalkan terminologi umum yang
digunakan dalam IoT. Kita belajar tentang arsitektur IoT untuk manajemen
data dan analisis data. Bigdata yang dihasilkan oleh perangkat IoT
memerlukan cara khusus untuk menanganinya.
Kita belajar tentang bagaimana ilmu data dan AI dapat membantu
dalam analitik dan prediksi yang dihasilkan oleh banyak perangkat IoT.
Berbagai platform IoT dijelaskan secara singkat dalam bab ini, seperti juga
beberapa vertikal IoT yang populer. Kita juga belajar tentang pustaka
Deeplearning khusus: TensorFlow dan Keras. Akhirnya, beberapa kumpulan
data yang akan kita gunakan di seluruh buku ini diperkenalkan.
28
Pada bagian selanjutnya akan membahas bagaimana mengakses set
data yang tersedia dalam berbagai format.
96
4. Bagian 4: Deep Learning untuk IoT
Di bab terakhir, kita belajar tentang berbagai algoritma
pembelajaran mesin atau Machine Learning (ML). Fokus bagian ini adalah
jaringan saraf yang didasarkan pada model berlapis ganda, yang juga dikenal
sebagai model pembelajaran dalam atau deep learning models. Mereka
telah menjadi kata kunci atau buzzword dalam beberapa tahun terakhir dan
menjadi favorit mutlak investor di bidang startup berbasis kecerdasan
buatan. Mencapai keakuratan di atas tingkat manusia dalam tugas
mendeteksi objek dan mengalahkan Dan Nine, master permainan Go dunia
adalah beberapa prestasi yang mungkin dicapai dengan deep learning (DL).
Pada bagian ini, kita akan belajar tentang berbagai model DL dan
cara menggunakan DL pada data yang dihasilkan IoT. Pada bab ini, kita akan
mulai dengan melihat sekilas perjalanan DL, dan mempelajari tentang empat
model populer, multilayered perceptron (MLP), convolutional neural
network (CNN), recurrent neural network (RNN), dan autoencoder. Secara
khusus, Anda akan mempelajari hal-hal berikut ini.
• Sejarah Deep Learning dan faktor-faktor yang bertanggung
jawab atas kesuksesannya saat ini.
• Neuron buatan dan bagaimana mereka dapat terhubung
untuk menyelesaikan masalah non-linier.
• Algoritma propagasi mundur dan menggunakannya untuk
melatih model MLP.
97
• Berbagai pengoptimal dan fungsi aktivasi tersedia di
TensorFlow.
• Bagaimana CNN bekerja dan konsep di balik kernel, padding,
dan langkah.
• Menggunakan model CNN untuk klasifikasi dan pengenalan
• RNN dan RNN yang dimodifikasi serta memori jangka pendek
dan unit berulang yang terjaga keamanannya.
• Arsitektur dan fungsi autoencoder.
4.1. Selayang pandang tentang Deep Learning
Pikiran manusia selalu membuat penasaran para filsuf, ilmuwan, dan
insinyur. Keinginan untuk meniru dan meniru kecerdasan otak manusia oleh
manusia telah dituliskan selama bertahun-tahun. Galatea oleh Pygmalion
dari Siprus dalam mitologi Yunani, Golem dalam cerita rakyat Yahudi, dan
Maya Sita dalam mitologi Hindu hanyalah beberapa contoh. Robot dengan
kecerdasan buatan atauArtificial Intelligence (AI) adalah favorit penulis fiksi
(sains) sejak jaman dahulu.
AI, seperti yang kita kenal sekarang, dipahami paralel dengan
gagasan komputer. Makalah dengan judulA Logical Calculus Of The Ideas
Immanent In Nervous Activity, pada tahun 1943 oleh McCulloch dan Pitts
mengusulkan model jaringan saraf pertama, yakni perangkat ambang batas
yang dapat melakukan operasi logis seperti AND, OR, AND-NOT. Dalam
karya perintisnya, Computing Machinery and Intelligence, yang diterbitkan
98
pada tahun 1950, Alan Turing mengusulkan tes Turing. Tes Turing
merupakan tes untuk mengidentifikasi apakah sebuah mesin memiliki
kecerdasan atau tidak. Rosenblatt, pada tahun 1957, meletakkan dasar bagi
jaringan yang dapat belajar dari pengalaman dalam laporannya, The
Perceptron — a perceiving and recognizing automation. Ide-ide ini jauh di
depan waktu mereka, sementara konsepnya tampak secara teoritis
mungkin, sumber daya komputasi pada saat itu sangat membatasi kinerja
yang dapat Anda peroleh melalui model yang dapat melakukan logika dan
belajar.
Gambar 14. Tren pencarian Deep Learning di mesin pencarian Google
Dua musim dingin AI dan beberapa keberhasilan kemudian (dengan
terobosan pada tahun 2012, ketika Alex Krizhvesky, Ilya Sutskever, dan entri
AlexNet Geoffrey Hinton dalam tantangan tahunan ImageNet mencapai
tingkat kesalahan 16%), hari ini kita berdiri di tempat di mana DL memiliki
mengungguli sebagian besar teknik AI yang ada. Gambar 14 berikut
merupakan cuplikan dari Google Trends menunjukkan bahwa, kira-kira
99
sekitar tahun 2014, Deep Learning menjadi populer dan terus berkembang
sejak saat itu. Selanjutnya mari kita lihat alasan di balik tren yang
berkembang ini dan analisis apakah itu hanya sensasi atau apakah ada lebih
dari itu.
4.1.1. Deep Learning, kenapa baru sekarang?
Sebagian besar konsep inti di bidang Deep Learning sudah ada pada
tahun 80-an dan 90-an dan oleh karena itu, muncul pertanyaan mengapa
tiba-tiba kita melihat peningkatan aplikasi DL untuk menyelesaikan masalah
yang berbeda dari klasifikasi gambar dan gambarinpainting, hingga mobil
yang mengemudi sendiri dan generasi rekognisi bicara. Alasan utamanya
ada dua, diuraikan sebagai berikut.
• Ketersediaan kumpulan data berkualitas tinggi yang besar:
Internet menghasilkan kumpulan data dalam jumlah besar
dalam hal gambar, video, teks, dan audio. Meskipun sebagian
besar tidak berlabel, dengan upaya banyak peneliti
terkemuka (misalnya, Fei Fei Li membuat set data ImageNet),
kita akhirnya memiliki akses ke set data berlabel besar. Jika
DL adalah tungku yang menerangi imajinasi Anda, data
adalah bahan bakar yang membakarnya. Semakin besar
jumlah dan variasi datanya, semakin baik performa model.
• Ketersediaan komputasi paralel menggunakan unit
pemrosesan grafis: Dalam model DL, terdapat dua operasi
100
matriks matematika yang memainkan peran penting, yaitu
perkalian matriks dan penambahan matriks. Kemungkinan
untuk memparalelkan proses ini untuk semua neuron dalam
satu lapisan dengan bantuan unit pemrosesan grafis atau
Graphical Processing Unit (GPU) memungkinkan untuk
melatih model DL dalam waktu yang wajar.
Setelah minat pada DL tumbuh, orang-orang datang dengan
peningkatan lebih lanjut, seperti pengoptimal yang lebih baik untuk
penurunan gradien (algoritma yang diperlukan yang digunakan untuk
menghitung bobot dan pembaruan bias dalam model DL), misalnya, Adam
dan RMSprop; teknik regularisasi baru seperti dropout dan normalisasi batch
yang membantu, tidak hanya dalam overfitting, tetapi juga dapat
mengurangi waktu pelatihan, dan terakhir, ketersediaan pustaka DL seperti
TensorFlow, Theano, Torch, MxNet, dan Keras, yang membuatnya lebih
mudah untuk mendefinisikan dan melatih arsitektur yang kompleks.
Menurut Andrew Ng, pendiri deeplearning.ai, meskipun banyak hype
dan investasi dahsyat tentang hal ini, kita tidak akan melihat musim dingin
AI lagi, karena peningkatan dalam perangkat komputasi akan menjaga
kemajuan kinerja dan terobosan datang di masa mendatang, kata Andrew
Ng ini di EmTech Digital pada tahun 2016, dan sesuai dengan prediksinya,
kita telah melihat kemajuan dalam perangkat keras pemrosesan dengan
Tensor Processing Unit (TPUs) Google, Intel Movidius, dan GPU terbaru
NVIDIA. Selain itu, ada GPU komputasi awan yang tersedia saat ini dengan
101
harga serendah 0,40 sen dolar atau sekitar enam ribu (dengan kurs lima
belas ribu rupiah per dolar) per jam, sehingga terjangkau untuk semua.
Anda dapat membaca artikel lengkap AI Winter Isn't Coming yang
diterbitkan di MIT Technology Review pada alamat laman berikut
ini,https://www.technologyreview.com/s/603062/ai-winter-isnt-coming/. Di sini
Andrew Ng menjawab berbagai pertanyaan tentang masa depan AI.
Untuk Deep Learning, kekuatan pemrosesan GPU adalah suatu
keharusan dan keutamaan. Ada sejumlah besar perusahaan yang
menawarkan layanan komputasi awan untuk hal yang sama. Tetapi jika
Anda memulai di lapangan, Anda dapat menggunakan salah satu dari
berikut ini.
• Google Colaboratory: Ini menyediakan antarmuka Jupyter
Notebook berbasis peramban dan berkemampuan GPU dan
TPU. Layanan ini memberikan akses gratis ke daya komputasi
GPU selama 12 jam terus menerus.
• Kaggle: Kaggle juga menyediakan antarmuka bergaya
Notebook Jupyter dengan daya komputasi GPU selama
kurang lebih enam jam tanpa biaya.
4.1.2. Artificial neuron
Komponen fundamental dari semua model DL adalahartificial neuron
atau neuron buatan. Neuron buatan terinspirasi oleh kerja neuron biologis.
102
Ini terdiri dari beberapa masukkan yang terhubung melalui bobot (juga
disebut koneksi sinaptik), jumlah bobot semua masukkan melalui fungsi
pemrosesan (disebut fungsi aktivasi) dan menghasilkan keluaran non-linier.
Gambar 15 menunjukkan representasi dari Neuron biologis dan
Neuron Buatan.
Gambar 15. Representasi neuron biologis dan neuron buatan
Jika Xi adalah input ke-i ke neuron buatan (j) yang terhubung melalui
koneksi sinaptik wij, maka masukkan bersih ke neuron, yang biasa disebut
aktivitas neuron, dapat didefinisikan sebagai jumlah tertimbang dari semua
isinya. , dan diberikan sebagai berikut.
Dalam persamaan sebelumnya, N adalah jumlah total masukan ke
neuron ke-j, dan θj adalah ambang batas neuron ke-j. Maka keluaran neuron
kemudian diberikan sebagai berikut.
103
Sebelumnya, g adalah fungsi aktivasi. Poin berikut mencantumkan
fungsi aktivasi berbeda yang digunakan dalam model Deep Learning
berbeda, bersama dengan representasi matematis dan grafisnya.
Fungsi sigmoid
Gambar 16. Representasi fungsi aktivasi sigmoid
Fungsi sigmoid adalah fungsi real yang dibatasi, dapat dibedakan,
yang didefinisikan untuk semua nilai input nyata dan memiliki turunan non-
negatif di setiap titik dan tepat satu titik belok. "Fungsi" sigmoid dan "kurva"
104
sigmoid mengacu pada objek yang sama.Contoh umum dari fungsi sigmoid
adalah fungsi logistik.
Fungsi hyperbolic Tangent
Gambar 17. Representasi fungsi aktivasi hyperbolic Tangent
Fungsi ini juga seperti sigmoid logistik tetapi lebih baik. Rentang
fungsi hyperbolic tangentatau tanh adalah dari (-1 hingga 1). Fungsi ini juga
sigmoidal (berbentuk s).Keuntungannya adalah bahwa masukan negatif
akan dipetakan dengan sangat negatif dan masukan nol akan dipetakan
105
mendekati nol dalam grafik tanh.Fungsinya bisa dibedakan.Fungsinya
monotonik sedangkan turunannya tidak monotonik.Fungsi tanh terutama
digunakan untuk klasifikasi antara dua kelas.Kedua fungsi aktivasi sigmoid
logistik danhyperbolic tangent dan digunakan dalam jaring umpan-maju.
Fungsi ReLU
Gambar 18. Representasi fungsi aktivasi ReLU disandingkan dengan Softplus
Fungsi aktivasi Rectified Linear Unit atau ReLu pertama kali
diperkenalkan ke jaringan dinamis oleh Hahnloser et al. pada tahun 2000
dengan motivasi biologis yang kuat dan pembenaran matematis. Fungsi ini
ditunjukkan untuk pertama kalinya pada tahun 2011 untuk memungkinkan
106
pelatihan yang lebih baik dari jaringan yang lebih dalam, dibandingkan
dengan fungsi aktivasi yang banyak digunakan sebelum 2011, misalnya,
sigmoid logistik dan lebih praktis, garis singgung hiperbolik. Penyearah atau
rectifier, mulai 2017, adalah fungsi ini menjadi fungsi aktivasi paling populer
untuk deep neural network.
Fungsi Softmax
Gambar 19. Representasi fungsi aktivasi Softmax
Dalam matematika, fungsi softmax, juga dikenal sebagai
softargmaxatau fungsi eksponensial ternormalisasi. Fungsi softmax adalah
fungsi yang mengambil masukkan vektor z dari bilangan real K, dan
107
menormalkannya menjadi distribusi probabilitas yang terdiri dari
Probabilitas K sebanding dengan eksponensial dari bilangan masukkan.
Artinya, sebelum menerapkan softmax, beberapa komponen vektor bisa
negatif, atau lebih besar dari satudan mungkin tidak berjumlah 1.Namun
setelah menerapkan softmax, setiap komponen akan berada dalam interval
(0, 1) dan komponen tersebut akan dijumlahkan menjadi 1, sehingga dapat
diartikan sebagai probabilitas.
Fungsi Leaky ReLU
Gambar 20. Representasi fungsi aktivasi Leaky ReLU
108
Leaky ReLU adalah salah satu upaya untuk memperbaiki masalah
"RELU sekarat". Alih-alih fungsi menjadi nol ketika x<0, Leaky ReLU yang
akan memiliki kemiringan negatif kecil (0,01, atau lebih). Artinya, fungsi
tersebut menghitung di mana α
adalah konstanta kecil. Beberapa orang melaporkan sukses dengan bentuk
fungsi aktivasi ini, tetapi hasilnya tidak selalu konsisten. Kemiringan di
wilayah negatif juga dapat dibuat menjadi parameter setiap neuron, seperti
yang terlihat pada neuron PReLU, diperkenalkan dalam Delving Deep into
Rectifier, oleh Kaiming He et al., 2015. Namun, konsistensi manfaat di
seluruh tugas saat ini tidak jelas.
Fungsi ELU
109
Gambar 21. Representasi fungsi aktivasi ELU
Unit Linear Eksponensial atau yang dikenal luas Exponential Linear
Unit (ELU) adalah fungsi yang cenderung menggabungkan biaya ke nol lebih
cepat dan menghasilkan hasil yang lebih akurat. Berbeda dengan fungsi
aktivasi lainnya, ELU memiliki konstanta alfa ekstra yang harus berupa
bilangan positif.ELU sangat mirip dengan RELU kecuali masukkan negatif.
Keduanya dalam bentuk fungsi identitas untuk masukkan non-negatif. Di sisi
lain, ELU menjadi halus secara perlahan hingga hasilnya sama dengan -α
sedangkan RELU menjadi halus dengan tajam.
Fungsi langkah Heaviside
110
Gambar 22. Representasi fungsi aktivasi threshold
Fungsi langkah Heaviside, atau fungsi langkah satuan, biasanya
dilambangkan dengan H atau θ (tetapi terkadang u, 1 atau 𝟙), adalah fungsi
terputus-putus, dinamai menurut Oliver Heaviside (1850–1925), yang
nilainya nol untuk argumen negatif dan satu untuk argumen non-negatif. Ini
adalah contoh kelas umum fungsi langkah, yang semuanya dapat
direpresentasikan sebagai kombinasi linear dari terjemahan yang satu ini.
Fungsi ini awalnya dikembangkan dalam kalkulus operasional untuk solusi
persamaan diferensial, di mana ia mewakili sinyal yang menyala pada waktu
tertentu dan tetap menyala tanpa batas. Oliver Heaviside, yang
mengembangkan kalkulus operasional sebagai alat analisis komunikasi
telegraf, merepresentasikan fungsi sebagai 1.
111
4.1.3. Memodelkan neuron tunggal dalam TensorFlow
Bisakah kita menggunakan neuron tunggal ini dan membuatnya
belajar? Jawabannya adalah bisa. Proses pembelajaran melibatkan
penyesuaian bobot sehingga fungsi kerugian yang telah ditentukan (L)
berkurang. Jika kita memperbarui bobot ke arah yang berlawanan dengan
gradien fungsi kerugian sehubungan dengan bobot, itu akan memastikan
bahwa fungsi kerugian berkurang dengan setiap pembaruan.
Algoritma ini disebut algoritma penurunan gradien, dan merupakan
inti dari semua modelDeep Learning. Secara matematis, jika L adalah fungsi
kerugian dan η kecepatan pembelajaran, maka bobot wij diperbarui dan
direpresentasikan sebagai.
Jika kita harus memodelkan neuron buatan tunggal, pertama-tama
kita harus memutuskan parameter berikut.
• Parameter kecepatan pembelajaran: Parameter kecepatan
pembelajaran menentukan seberapa cepat kita menurunkan
gradien. Biasanya, ini terletak di antara 0 dan 1. Jika
kecepatan pembelajaran terlalu tinggi, jaringan dapat
berosilasi di sekitar solusi yang benar atau sama sekali
menyimpang dari solusi. Di sisi lain, jika kecepatan
pemelajaran terlalu rendah, akan membutuhkan waktu lama
untuk akhirnya dapat digabungkan ke solusi.
112
• Fungsi aktivasi: Fungsi aktivasi memutuskan bagaimana
keluaran neuron bervariasi dengan aktivitasnya. Karena
persamaan pembaruan bobot melibatkan turunan dari fungsi
kerugian, yang pada gilirannya akan bergantung pada
turunan fungsi aktivasi, kita lebih memilih fungsi yang dapat
dibedakan secara kontinu sebagai fungsi aktivasi untuk
neuron. Awalnya, sigmoid dan hiperbolik tangen digunakan,
tetapi mereka menderita konvergensi lambat dan gradien
menghilang (gradien menjadi nol, dan karenanya, tidak ada
pembelajaran, sementara solusi belum tercapai). Dalam
beberapa tahun terakhir, rectified liniear unit (ReLU) dan
variannya seperti Leaky ReLU dan ELU lebih disukai karena
menawarkan konvergensi yang cepat dan pada saat yang
sama, membantu mengatasi masalah gradien yang
menghilang. Di ReLU, terkadang kita mengalami masalah
neuron mati, yaitu beberapa neuron tidak pernah aktif
karena aktivitasnya selalu kurang dari nol, sehingga tidak
pernah belajar. Baik Leaky ReLU dan ELU mengatasi masalah
neuron mati dengan memastikan keluaran neuron bukan nol,
bahkan ketika aktivitasnya negatif. Daftar fungsi aktivasi yang
umum digunakan, dan representasi matematis dan grafisnya
dijelaskan sebelum bagian ini.
• Fungsi kerugian: Fungsi kerugian adalah parameter yang coba
diminimalkan oleh jaringan kita, sehingga memilih fungsi
kerugian yang tepat sangat penting untuk pembelajaran. Saat
113
Anda mempelajari Deep Learning lebih dalam, Anda akan
menemukan banyak fungsi kerugian yang didefinisikan
dengan cerdas. Anda akan melihat bagaimana, dengan
mendefinisikan fungsi kerugian dengan benar, kita dapat
membuat model Deep Learning kita membuat gambar baru,
memvisualisasikan mimpi, atau memberi keterangan pada
gambar, dan banyak lagi. Secara konvensional, tergantung
pada jenis regresi atau klasifikasi tugas, orang menggunakan
mean square error (MSE) atau fungsi kerugian entropi lintas
kategorikal. Anda akan mempelajari fungsi kerugian ini saat
kita melanjutkan membaca buku ini.
Sekarang kita mengetahui elemen dasar yang diperlukan untuk
memodelkan neuron buatan, mari kita mulai dengan pengkodean. Kita akan
menganggap tugas regresi, jadi kita akan menggunakan fungsi kerugian
MSE. Jika yj adalah keluaran dari neuron tunggal kita untuk vektor masukan
X dan merupakan keluaran yang kita inginkan untuk keluaran neuron j,
maka kesalahan MSE secara matematis dinyatakan sebagai (rata-rata
kuadrat kesalahan ), ditunjukkan sebagai berikut.
Sebelumnya, M adalah jumlah total sampel pelatihan (pasangan masukkan
dan keluaran).
114
Perhatikan bahwa jika Anda akan mengimplementasikan neuron
buatan ini tanpa menggunakan TensorFlow (untuk lebih spesifiknya tanpa
menggunakan salah satu pustaka Deep Learning yang disebutkan
sebelumnya), Anda perlu menghitung sendiri gradiennya, misalnya, Anda
akan menulis fungsi atau kode yang pertama-tama akan menghitung fungsi
gradien kerugian, dan kemudian Anda harus menulis kode untuk
memperbarui semua bobot dan bias. Untuk satu neuron dengan fungsi
kerugian MSE, menghitung turunan masih mudah, tetapi dengan
meningkatnya kompleksitas jaringan, menghitung gradien untuk fungsi
kerugian tertentu, melakukan implementasi dalam kode, dan akhirnya
memperbarui bobot dan bias bisa menjadi sangat tindakan rumit.
TensorFlowmembuat seluruh proses ini lebih mudah dengan
menggunakan diferensiasi otomatis. TensorFlow menentukan semua
operasi dalam grafik TensorFlow.Hal ini memungkinkannya untuk
menggunakan aturan rantai dan menjadi rumit dalam menetapkan gradien
pada grafik.
Jadi, di TensorFlow kita membuat grafik eksekusi, dan menentukan
fungsi kerugian kita, kemudian menghitung gradien secara otomatis, dan
mendukung banyak gradien berbeda, menghitung algoritma (pengoptimal),
yang dapat kita gunakan dengan mudah.Anda dapat mempelajari lebih
lanjut tentang konsep diferensiasi otomatis melalui tautan ini:
http://www.columbia.edu/~ahd2125/post/2015/12/5/.
Sekarang dengan semua informasi dasar ini, mari kita membangun
neuron tunggal kita di TensorFlow dengan langkah-langkah berikut:
115
1. Langkah pertama, di setiap kode Python, selalu mengimpor modul
yang akan dibutuhkan di seluruh program. Kita akan mengimpor
TensorFlow untuk membuat neuron buatan tunggal. Numpy dan
pandas dibutuhkan untuk mendukung kalkulasi matematika dan
untuk membaca berkas data. Selain itu, kita juga mengimpor
beberapa fungsi yang berguna (untuk normalisasi data, membaginya
menjadi latih, validasi, dan mengacak data) dari scikit-learn, kita
telah menggunakan fungsi-fungsi ini di bagian sebelumnya dan
mengetahui bahwa normalisasi dan pengacakan adalah langkah
penting dalam pipeline AI apa pun.
import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.utils import shuffle
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
% matplotlib inline
2. Di TensorFlow, pertama-tama kita membuat grafik model, lalu
menjalankannya. Ini mungkin, saat memulai, tampak rumit, tetapi
setelah Anda memahaminya, akan sangat mudah dan
memungkinkan kita mengoptimalkan kode untuk produksi. Jadi,
pertama-tama mari kita tentukan grafik neuron tunggal kita. Kita
116
mendefinisikan self.X dan self.y sebagai placeholder untuk
meneruskan data ke grafik, seperti yang ditunjukkan pada kode
berikut.
class ArtificialNeuron:
def __init__(self,N=2, act_func=tf.nn.sigmoid, learning_rate= 0.001):
self.N = N # Number of inputs to the neuron
self.act_fn = act_func
# membuat grafik untuk nouron tunggal
self.X = tf.placeholder(tf.float32, name='X', shape=[None,N])
self.y = tf.placeholder(tf.float32, name='Y')
3. Bobot dan bias didefinisikan sebagai variabel sehingga diferensiasi
otomatis memperbaruinya secara otomatis. TensorFlow
menyediakan antarmuka grafis untuk mendukung TensorBoard
untuk melihat struktur grafik, serta parameter yang berbeda, dan
bagaimana perubahannya selama pelatihan. Ini bermanfaat untuk
men-debug dan memahami bagaimana model Anda berperilaku.
Oleh karena itu, dalam kode berikut, kita menambahkan baris kode
untuk membuat ringkasan histogram untuk bobot dan bias.
self.W = tf.Variable(tf.random_normal([N,1], stddev=2, seed = 0), \
name = "weights")
self.bias = tf.Variable(0.0, dtype=tf.float32, name="bias")
tf.summary.histogram("Weights",self.W)
117
tf.summary.histogram("Bias", self.bias)
4. Selanjutnya, kita melakukan operasi matematika, perkalian matriks,
antara masukkan dan bobot, menambahkan bias, dan menghitung
aktivitas neuron dan keluarannya, dilambangkan dengan self.y_hat
ditunjukkan sebagai berikut.
activity = tf.matmul(self.X, self.W) + self.bias
self.y_hat = self.act_fn(activity)
5. Kita mendefinisikan fungsi kerugian yang kita ingin model
meminimalkannya, dan menggunakan pengoptimal TensorFlow
untuk meminimalkannya, dan memperbarui bobot dan bias
menggunakan pengoptimal penurunan gradien, seperti yang
ditunjukkan pada kode berikut.
error = self.y - self.y_hat
self.loss = tf.reduce_mean(tf.square(error))
self.opt = tf.train.GradientDescentOptimizer(\
learning_rate=learning_rate).minimize(self.loss)
6. Kita menyelesaikan fungsi init dengan menentukan Sesi TensorFlow
dan menginisialisasi semua variabel. Kita juga menambahkan kode
untuk memastikan bahwa TensorBoard menulis semua ringkasan di
tempat yang ditentukan, yang ditunjukkan sebagai berikut.
tf.summary.scalar("loss",self.loss)
118
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
self.merge = tf.summary.merge_all()
self.writer = tf.summary.FileWriter("logs/",\
graph=tf.get_default_graph())
7. Kita mendefinisikan fungsi latih di mana grafik yang kita buat
sebelumnya dijalankan, seperti yang ditunjukkan pada kode berikut.
def train(self, X, Y, X_val, Y_val, epochs=100):
epoch = 0
X, Y = shuffle(X,Y)
loss = []
loss_val = []
while epoch &lt; epochs:
# Jalankan pengoptimal untuk seluruh kumpulan
#(Penurunan Gradien Stokastik)
merge, _, l = self.sess.run([self.merge,self.opt,self.loss],\
feed_dict={self.X: X, self.y: Y})
l_val = self.sess.run(self.loss, feed_dict={self.X: X_val, \
self.y: Y_val})
119
loss.append(l)
loss_val.append(l_val)
self.writer.add_summary(merge, epoch)
if epoch % 10 == 0:
print("Epoch {}/{} training loss: {} Validation loss {}".\
format(epoch,epochs,l, l_val ))
epoch += 1
return loss, loss_val
8. Untuk membuat predict atau prediksi, kita juga menyertakan
metode prediksi, seperti yang ditunjukkan pada kode berikut.
def predict(self, X):
return self.sess.run(self.y_hat, feed_dict={self.X: X})
9. Selanjutnya, seperti di bab sebelumnya, kita membaca data,
menormalkannya menggunakan fungsi scikit-learn, dan
membaginya menjadi set pelatihan dan validasi, yang ditunjukkan
sebagai berikut.
filename = 'Folds5x2_pp.xlsx'
df = pd.read_excel(filename, sheet_name='Sheet1')
X, Y = df[['AT', 'V','AP','RH']], df['PE']
scaler = MinMaxScaler()
X_new = scaler.fit_transform(X)
120
target_scaler = MinMaxScaler()
Y_new = target_scaler.fit_transform(Y.values.reshape(-1,1))
X_train, X_val, Y_train, y_val = \
train_test_split(X_new, Y_new, test_size=0.4, random_state=333)
10. Kita menggunakan neuron buatan yang kita buat untuk membuat
prediksi keluaran energi. Kerugian Pelatihan dan Validasi Kerugian
diplot sebagai pembelajaran neuron buatan, seperti yang
ditunjukkan berikut ini.
_, d = X_train.shape
model = ArtificialNeuron(N=d)
loss, loss_val = model.train(X_train, Y_train, X_val, y_val, 30000)
plt.plot(loss, label="Taining Loss")
plt.plot(loss_val, label="Validation Loss")
plt.legend()
plt.xlabel("Epochs")
plt.ylabel("Mean Square Error")
121
Gambar 23. Mean Square Error dari data latih dan validasi pada neuron tunggal dari set
data keluaran energi yang dijelaskan pada bagian pertama
4.2. Multilayered preceptrons untuk regresi dan
klasifikasi
Sebelumnya Anda telah mempelajari tentang satu neuron buatan
dan menggunakannya untuk memprediksi keluaran energi. Jika kita
membandingkannya dengan hasil regresi linier bagian ke-3, kita dapat
melihat bahwa meskipun neuron tunggal melakukan pekerjaan dengan baik,
itu tidak sebaik regresi linier. Arsitektur neuron tunggal memiliki nilai MSE
0,078 pada set data validasi dibandingkan 0,01 pada regresi linier.
122
Bisakah kita membuatnya lebih baik, dengan mungkin lebih banyak
waktu, atau kecepatan pembelajaran yang berbeda, atau mungkin lebih
banyak neuron tunggal. Sayangnya tidak, neuron tunggal hanya dapat
menyelesaikan masalah yang dapat dipisahkan secara linier, misalnya,
neuron dapat memberikan solusi hanya jika terdapat garis lurus yang
memisahkan kelas atau keputusan.
Jadi apa yang kita lakukan? Kita dapat menggunakan banyak lapisan
neuron tunggal, dengan kata lain, menggunakan preseptron lapis multi atau
Multilayered Preceptrons(MLP). Sama seperti dalam kehidupan nyata, kita
memecahkan masalah yang kompleks dengan memecahnya menjadi
masalah kecil, setiap neuron di lapisan pertama MLP memecah masalah
menjadi masalah kecil yang dapat dipisahkan secara linier. Karena informasi
mengalir di sini dalam satu arah dari lapisan masukan ke lapisan keluaran
melalui lapisan tersembunyi, jaringan ini juga disebut jaringan umpan maju.
Pada Gambar 24 kita akan melihat bagaimana masalah XOR
diselesaikan menggunakan dua neuron di lapisan pertama, dan satu neuron
di Lapisan Keluaran. Jaringan memecah masalah yang dapat dipisahkan
secara non-linier menjadi tiga masalah yang dapat dipisahkan secara linier.
123
Gambar 24. Masalah XOR yang diselesaikan dengan preseptron lapis multi
Dari Gambar 24 tersebut dapat dijelaskan sebagai XOR diselesaikan
menggunakan MLP dengan satu lapisan tersembunyi dengan neuron dan
satu neuron di lapisan keluaran. Titik merah melambangkan nol dan titik
biru melambangkan satu. Kita dapat melihat bahwa neuron tersembunyi
memisahkan masalah menjadi dua masalah yang dapat dipisahkan secara
linier (AND dan OR), neuron keluaran kemudian mengimplementasikan
logika lain yang dapat dipisahkan secara linier, logika AND-NOT,
menggabungkannya bersama-sama kita dapat menyelesaikan XOR, yang
tidak dapat dipisahkan secara linier.
Neuron tersembunyi mengubah masalah menjadi bentuk yang dapat
digunakan lapisan keluaran. Gagasan tentang beberapa lapisan neuron
diberikan oleh McCulloch dan Pitts sebelumnya, tetapi sementara
124
Rosenblatt memberikan algoritma pembelajaran untuk perseptron
sederhana, dia tidak memiliki cara untuk melatih beberapa perseptron
berlapis.
Kesulitan utama adalah bahwa, sementara untuk neuron keluaran
kita tahu apa yang seharusnya menjadi keluaran yang diinginkan sehingga
dapat menghitung kesalahan, dan karenanya, fungsi kerugian dan
pembaruan bobot menggunakan penurunan gradien, tidak ada cara untuk
mengetahui keluaran yang diinginkan dari neuron tersembunyi.
Oleh karena itu, dengan tidak adanya algoritma pembelajaran, MLP
tidak pernah banyak dieksplorasi. Iniberubah pada tahun 1982 ketika Hinton
mengusulkan algoritma propagasi mundur,yang dapat digunakan untuk
menghitung kesalahan, dan karenanya, pembaruan bobot untukneuron
tersembunyi.
Mereka menggunakan trik matematika diferensiasi yang rapi dan
lugas menggunakan aturan rantai, dan memecahkan masalah melewatkan
kesalahan pada lapisan keluaran kembali ke neuron tersembunyi, dan pada
gilirannya, meningkatkan kehidupan kembali ke jaringan saraf. Saat ini,
algoritme propagasi mundur merupakan inti dari hampir semua model Deep
Learning.
125
4.2.1. Algoritma backrpopagation
Mari kita dapatkan sedikit pemahaman tentang teknik di balik
algoritma backpropagation atau propagasi mundur. Jika Anda ingat dari
bagian sebelumnya, fungsi kerugian pada neuron keluaran adalah sebagai
berikut.
Anda dapat melihat bahwa itu tidak berubah, sehingga bobot yang
menghubungkan neuron tersembunyi k ke neuron keluaran j akan diberikan
sebagai berikut.
Dengan menerapkan aturan rantai diferensiasi, persamaan tersebut
mereduksi menjadi sebagai berikut.
Dalam persamaan sebelumnya, Ok adalah keluaran dari neuron tersembunyi
k. Sekarang pembaruan berat yang menghubungkan neuron masukkani ke
neuron tersembunyi k dari lapisan tersembunyi n dapat ditulis sebagai
berikut.
126
Sekali lagi menerapkan aturan rantai, ini mengurangi menjadi berikut:
Di sini, Oi adalah keluaran dari neuron tersembunyi i di lapisan
tersembunyi n-1th. Karena kita menggunakan TensorFlow, maka kita tidak
perlu repot menghitung gradien ini.Tetapi tetap saja, ada baiknya untuk
mengetahui ekspresinya. Dari ekspresi ini, Anda dapat melihat mengapa
penting bahwa fungsi aktivasi dapat dibedakan.
Pembaruan bobot sangat bergantung pada turunan dari fungsi
aktivasi, serta masukan ke neuron. Oleh karena itu, fungsi turunan yang
halus seperti itu dalam kasus ReLU dan ELU menghasilkan konvergensi yang
lebih cepat. Jika turunan menjadi terlalu besar, kita memiliki masalah
gradien yang eksplosif, dan jika turunannya menjadi hampir nol, kita
memiliki masalah gradien yang hilang. Dalam kedua kasus tersebut, jaringan
tidak belajar secara optimal.
Sekarang kita dapat menjelaskan langkah-langkah yang terlibat
dalam algoritma propagasi mundur, yang terdaftar sebagai berikut:
1. Terapkan masukkan ke jaringan
2. Menyebarkan masukan ke depan dan menghitung keluaran jaringan
127
3. Hitung kerugian pada keluaran, dan kemudian gunakan ekspresi
sebelumnya, hitung pembaruan bobot untuk neuron lapisan
keluaran
4. Menggunakan galat bobot pada lapis keluaran, hitung bobot terbaru
untuk lapis tersembunyi
5. Perbarui semua bobot
6. Ulangi langkah-langkah tersebut untuk contoh pelatihan lainnya
4.2.2. Prediksi keluaran energi menggunakan MLP di TensorFlow
Sekarang mari kita lihat seberapa baik MLP untuk memprediksi
keluaran energi. Ini akan menjadi masalah regresi. Kita akan menggunakan
MLP lapisan tersembunyi tunggal dan akan memprediksi keluaran energi
listrik bersih per jam dari pembangkit listrik siklus gabungan. Karena ini
adalah masalah regresi, fungsi kerugian kita tetap sama seperti sebelumnya.
Kode lengkap yang mengimplementasikan kelas MLP diberikan sebagai
berikut.
class MLP:
def __init__(self,n_input=2,n_hidden=4, n_output=1, \
act_func=[tf.nn.elu, tf.sigmoid], learning_rate= 0.001):
self.n_input = n_input # Number of inputs to the neuron
self.act_fn = act_func
128
seed = 123
self.X = tf.placeholder(tf.float32, name='X', shape=[None,n_input])
self.y = tf.placeholder(tf.float32, name='Y')
# Membuat grafik untuk neuron tunggal
# Lapisan tersembunyi
self.W1 = tf.Variable(tf.random_normal([n_input,n_hidden],\
stddev=2, seed = seed), name = "weights")
self.b1 = tf.Variable(tf.random_normal([1, n_hidden], seed = seed),\
name="bias")
tf.summary.histogram("Weights_Layer_1",self.W1)
tf.summary.histogram("Bias_Layer_1", self.b1)
# Lapian keluaran
self.W2 = tf.Variable(tf.random_normal([n_hidden,n_output],\
stdev=2, seed = 0), name = "weights")
self.b2 = tf.Variable(tf.random_normal([1, n_output], seed = seed),\
name="bias")
tf.summary.histogram("Weights_Layer_2",self.W2)
tf.summary.histogram("Bias_Layer_2", self.b2)
activity = tf.matmul(self.X, self.W1) + self.b1
h1 = self.act_fn[0](activity)
129
activity = tf.matmul(h1, self.W2) + self.b2
self.y_hat = self.act_fn[1](activity)
error = self.y - self.y_hat
self.loss = tf.reduce_mean(tf.square(error))\
+ 0.6*tf.nn.l2_loss(self.W1)
self.opt = tf.train.GradientDescentOptimizer(learning_rate\
=learning_rate).minimize(self.loss)
tf.summary.scalar("loss",self.loss)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
self.merge = tf.summary.merge_all()
self.writer = tf.summary.FileWriter("logs/",\
graph=tf.get_default_graph())
def train(self, X, Y, X_val, Y_val, epochs=100):
epoch = 0
X, Y = shuffle(X,Y)
loss = []
loss_val = []while epoch &lt; epochs:
# Menjalankan pengoptimalisasi untuk set latih
130
merge, _, l = self.sess.run([self.merge,self.opt,self.loss],\
feed_dict={self.X: X, self.y: Y})
l_val = self.sess.run(self.loss, feed_dict=\
{self.X: X_val, self.y: Y_val})
loss.append(l)
loss_val.append(l_val)
self.writer.add_summary(merge, epoch)
if epoch % 10 == 0:
print("Epoch {}/{} training loss: {} Validation loss {}".\
format(epoch,epochs,l, l_val ))
epoch += 1
return loss, loss_val
def predict(self, X):
return self.sess.run(self.y_hat, feed_dict={self.X: X})
Sebelum menggunakannya, mari kita lihat perbedaan antara kode
sebelumnya dan kode yang kita buat sebelumnya untuk neuron buatan
tunggal. Di sini dimensi bobot lapisan tersembunyi adalah #inputUnits ×
#hiddenUnits, bias lapisan tersembunyi akan sama dengan jumlah unit
tersembunyi (#hiddenUnits). Bobot lapisan keluaran memiliki dimensi
131
#hiddenUnits × #outputUnits, bias lapisan keluaran adalah dimensi jumlah unit
di lapisan keluaran (#outputUnits).
Dalam mendefinisikan bias, kita hanya menggunakan dimensi kolom,
bukan baris. Ini karena TensorFlow seperti pustaka numpy membuat m
sesuai dengan operasi yang akan dilakukan dan dengan tidak memperbaiki
bias dimensi baris, kita dapat menjaga fleksibilitasjumlah sampel pelatihan
masukkan (ukuran batch) yang kita sajikan ke jaringan.Gambar 25
menunjukkan perkalian matriks dan dimensi penambahan saat menghitung
aktivitas.
Perbedaan kedua yang harus Anda perhatikan adalah dalam definisi
kerugian, kita telah menambahkan istilah regularisasi l2 untuk mengurangi
overfitting seperti yang dibahas di Bagian3 yang ditampilkan sebagai berikut.
self.loss = tf.reduce_mean (tf.square (error)) + 0.6 * \
tf.nn.l2_loss (self.W1)
132
Gambar 25. Pekalian matrik dan dimensi penjumlahan dalam penghitungan aktivitas
Setelah membaca data dari berkas csv dan memisahkannya menjadi
latih dan validasi seperti sebelumnya, kita mendefinisikan objek kelas MLP
dengan 4 neuron di lapisan masukan, 15 neuron di lapisan tersembunyi, dan
1neuron di lapisan keluaran.
_, d = X_train.shape
_, n = Y_train.shape
model = MLP (n_input = d, n_hidden = 15, n_output = n)
Dalamkodeberikutkitamelatih model pada set data latihuntuk 6000 epoch.
loss, loss_val = model.train (X_train, Y_train, X_val, y_val, 6000)
133
Jaringan terlatih ini memberi kita MSE sebesar 0,016 dan nilai R2 sebesar
0,67. Keduanya lebih baik daripada yang kita peroleh dari satu neuron, dan
sebanding dengan metode ML yang kita pelajari di Bagian 3.
Anda dapat bermain-main dengan hyperparameter yaitu: jumlah
neuron tersembunyi, fungsi aktivasi, kecepatan pembelajaran, pengoptimal
t, dan koefisien regularisasi. Dari mengubah-ubah nilai tersebut dapat
memperoleh hasil yang lebih baik.
4.3. Convolutional neural networks
MLP memang menyenangkan, tetapi seperti yang harus Anda amati
saat bermain dengan kode MLP di bagian sebelumnya, waktu untuk belajar
meningkat seiring dengan meningkatnya kompleksitas dimensi dari data
masukkan.Selain itu, kinerja MLP hanya berada di urutan kedua setelah
algoritma ML. Apa pun yang dapat Anda lakukan dengan MLP, ada
kemungkinan besar Anda dapat melakukannya sedikit lebih baik
menggunakan algoritma ML yang Anda pelajari di Bagian 3. Justru karena
alasan ini, meskipun algoritma propagasi mundur tersedia pada 1980-an,
tetapi kita telah mengamati musim dingin AI kedua kira-kira dari 1987
hingga 1993.
Ini semua berubah, dan jaringan saraf berhenti memainkan peran
kedua untuk algoritma ML, pada tahun 2010 dengan pengembangan
jaringan saraf dalam. Saat ini DL telah mencapai tingkat manusia atau lebih
dari kinerja tingkat manusia dalam berbagai tugas penglihatan komputer
134
seperti mengenali sinyal lalu, wajah, angka tulisan tangan, dan seterusnya.
Daftarnya kegunaannya akan terus bertambah.
CNN telah menjadi bagian utama dari kisah sukses ini. Kali ini, Anda
akan mempelajari tentang CNN, matematika di balik CNN, dan beberapa
arsitektur CNN yang populer.
4.3.1. Lapisan CNN yang berbeda
CNN terdiri dari tiga tipe utama lapisan neuron, lapisan konvolusi,
lapisan penggabungan, dan lapisan yang terhubung sepenuhnya. Lapisan
yang sepenuhnya terhubung tidak lain adalah lapisan MLP, mereka selalu
merupakan beberapa lapisan terakhir CNN, dan melakukan tugas akhir
klasifikasi atau regresi. Mari kita lihat bagaimana lapisan konvolusi atau
convolution layer dan lapisan penyatuan maksimal atau max pooling layers
bekerja.
4.3.2. Lapisan convolution
Lapisan ini adalah bagian inti CNN. Pada lapisan ini melakukan
operasi matematika yang mirip dengan konvolusi (korelasi silang atau cross-
correlation tepatnya) pada masukkannya yang biasanya adalah gambar 3D.
Ini ditentukan oleh kernel (filter). Ide dasarnya adalah filter ini berjalan di
seluruh gambar dan mengekstrak fitur tertentu dari gambar.
135
Sebelum masuk ke detail lebih lanjut, mari kita lihat operasi
konvolusi pada matriks dua dimensi untuk kesederhanaan. Gambar 26
menunjukkan operasi ketika satu piksel yang ditempatkan pada posisi [2, 2]
dari matriks gambar 2D 7 × 7 dililitkan dengan filter 3 × 3.
Gambar 26. Operasi konvolutional matriks 7 × 7 dengan filter 3 × 3
Operasi konvolusi melibatkan penempatan filter dengan piksel di
tengah, kemudian melakukan perkalian elemen-bijaksana antara elemen
filter dan piksel, bersama dengan tetangganya. Terakhir, menjumlahkan
produk. Karena operasi konvolusi dilakukan pada piksel, filter biasanya
berukuran ganjil seperti 5 × 5, 3 × 3, atau 7 × 7, dan seterusnya. Ukuran filter
menentukan seberapa banyak area di sekitarnya yang
136
dicakupnya.Parameter penting saat mendesain lapisan konvolusi adalah
sebagai berikut.
• Ukuran filter (k × k).
• Jumlah filter di lapisan, juga disebut channel. Gambar berwarna
input hadir di tiga saluran RGB. Jumlah channel secara konvensional
ditingkatkan pada lapisan yang lebih tinggi. Menghasilkan informasi
yang lebih dalam di lapisan yang lebih tinggi.
• Jumlah piksel yang dilewati filter (s) pada gambar. Biasanya,
langkahnya adalah satu piksel sehingga filter menutupi seluruh
gambar mulai dari kiri atas hingga kanan bawah.
• Padding yang akan digunakan saat berbelit-belit. Secara tradisional,
ada dua opsi, valid atau sama. Dalam padding yang valid, tidak ada
padding sama sekali, sehingga ukuran gambar berbelit-belit lebih
kecil dari aslinya. Demikian pula, padding nol dilakukan di sekitar
piksel batas, sehingga ukuran gambar berbelit-belit sama dengan
gambar aslinya.
4.3.3. Lapisan pooling
Secara konvensional, lapisan konvolusi diikuti oleh lapisan pooling.
Tujuan dari lapisanpoolingadalah untuk secara progresif mengurangi jumlah
representasi, dan dengan demikian dapat mengurangi jumlah parameter
dan perhitungan dalam jaringan. Maka itu menurunkan sampel informasi
saat menyebar melalui jaringan dengan cara umpan maju.
137
Di sini sekali lagi, kita memiliki filter, secara tradisional orang lebih
suka filter berukuran 2 × 2 dan itu bergerak dengan langkah dua piksel di
kedua arah. Proses pooling menggantikan empat elemen di bawah filter 2 ×
2 baik dengan nilai maksimum dari empat (Penggabungan Maks atau Max
Pooling) atau nilai rata-rata dari keempat (Penggabungan Rata-rata atau
Average Pooling). Dalam Gambar 27 berikut, Anda dapat melihat hasil
operasi penggabungan pada potongan saluran 2D dari sebuah gambar.
Gambar 27.Pooling maksimal dan rata-rata
Beberapa lapisan penggabungan konvolusi ditumpuk bersama untuk
membentuk CNN yang dalam. Saat gambar menyebar melalui CNN, setiap
lapisan konvolusional mengekstrak fitur tertentu. Lapisan bawah
mengekstrak fitur kasar seperti bentuk, kurva, garis, dan sebagainya,
sedangkan lapisan yang lebih tinggi mengekstrak fitur yang lebih abstrak
seperti mata, bibir, dan sebagainya. Gambar, saat menyebar melalui
jaringan, berkurangnya dimensinya, tetapi kedalamannya bertambah.
138
Keluaran dari lapisan konvolusional terakhir diratakan dan diteruskan ke
lapisan yang terintegrasi terhubung, seperti yang ditunjukkan pada Gambar
28.
Gambar 28. Arsitektur dasar dari jaringan CNN
Nilai matriks filter juga disebut bobot dan dikirim oleh seluruh
gambar. Pembagian ini mengurangi jumlah parameter pelatihan. Bobot
belajar jaringan menggunakan algoritma propagasi mundur.Karena kita akan
menggunakan fitur diferensiasi otomatis TensorFlow, kita tidak menghitung
nilai yang tepat untuk pembaruan bobot untuk lapisan konvolusi.
4.3.4. Beberapa model CNN yang populer
Berikut ini adalah daftar dari beberapa model CNN populer yang
tersedia.
139
• LeNet: LeNet adalah CNN pertama yang berhasil diterapkan
untuk mengenali angka tulisan tangan. Ini dikembangkan oleh
Yann LeCun pada 1990-an. Anda dapat mengetahui lebih banyak
tentang arsitektur LeNet dan publikasi terkait di halaman muka
Yann LeCun (http://yann.lecun.com/exdb/lenet/).
• VGGNet: Ini adalah runner-up di ILSVRC 2014, yang
dikembangkan oleh Karen Simonyan dan Andrew Zisserman.
Versi pertamanya berisi 16 lapisan Convolution + FC dan disebut
VGG16, kemudian mereka membawa VGG19 dengan 19 lapisan.
Rincian tentang kinerja dan publikasinya dapat diakses dari
laman tentang VGCNet pada situs departemen sains teknik
Universitas Oxford
(http://www.robots.ox.ac.uk/~vgg/research/very_deep/).
• ResNet: Dikembangkan oleh Kaiming He dkk., ResNet adalah
pemenang ILSVRC 2015. ResNet menggunakan fitur baru yang
disebut pembelajaran residual dan normalisasi batch. Ini adalah
jaringan yang sangat dalam dengan lebih dari 100 lapisan.
Diketahui bahwa menambahkan lebih banyak lapisan akan
meningkatkan kinerja, tetapi menambahkan lapisan juga
memperkenalkan masalah gradien yang hilang. ResNet
memecahkan masalah ini dengan memanfaatkan koneksi
pintasan identitas, di mana sinyal melewati satu atau lebih
lapisan. Anda dapat membaca makalah asli untuk informasi lebih
lanjut (https://arxiv.org/abs/1512.03385).
140
• GoogleNet: Ini adalah arsitektur pemenang ILSVRC 2014. Ini
memiliki 22 lapisan, dan memperkenalkan ide lapisan awal. Ide
dasarnya adalah untuk mencakup area yang lebih besar,
sementara pada saat yang sama, pertahankan resolusi yang
bagus untuk informasi kecil pada gambar. Hasilnya, alih-alih satu
ukuran filter, di setiap lapisan, kita memiliki filter mulai dari 1 × 1
(untuk detail halus) hingga 5 × 5. Hasil dari semua filter
digabungkan dan diteruskan ke lapisan berikutnya, proses
diulangi di lapisan awal berikutnya.
4.3.5. LeNet untuk mengenali angka tulisan tangan
Mari kitamencoba gunakan arsitektur LeNet yang diusulkan oleh
Yann LeCun untuk mengenali angka tulisan tangan. Arsitektur ini digunakan
olehLayanan Pos AS untuk mengenali kode ZIP tulisan tangan pada surat
yang mereka terima (http://yann.lecun.com/exdb/publis/pdf/jackel-95.pdf).
LeNet terdiri dari lima lapisan dengan dua lapisan kumpulan
konvolusional maksimal atau mac pool layers dan tiga lapisan yang
terhubung sepenuhnya. Jaringan juga menggunakan fitur dropout, yaitu
pada saat pelatihan beberapa bobot dimatikan. Ini memaksa interkoneksi
lain untuk mengimbanginya, dan karenanya membantu dalam mengatasi
overfitting.
141
1. Kita mengimpor modul yang diperlukan seperti yang ditunjukkan
sebagai berikut.
# Impor Modul
import numpy as np import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
2. Selanjutnya, kita membuat objek kelas LeNet, yang akan memiliki
arsitektur dan modul CNN yang diperlukan untuk melatih dan
membuat prediksi. Dalam metode init, kita mendefinisikan
semua placeholder yang diperlukan untuk menyimpan gambar
masukan dan label keluarannya. Kita juga mendefinisikan
kerugian, karena ini adalah masalah klasifikasi, kita menggunakan
kerugian lintas entropi, seperti yang ditunjukkan pada kode
berikut.
# Mendefinisikan arsitektur dengan mengimpor TensorFlow
from tensorflow.contrib.layers import flatten
class my_LeNet:
def __init__ (self, d, n, mu = 0, sigma = 0.1, lr = 0.001):
self.mu = mu
self.sigma = sigma
self.n = n
142
# place holder untuk masukkan gambar dengan dimensi 28 x 28
self.x = tf.placeholder(tf.float32, (None, d, d, 1))
self.y = tf.placeholder(tf.int32, (None,n))
# probabilitas untuk menyimpan unit
self.keep_prob = tf.placeholder(tf.float32)
self.logits = self.model(self.x)
# Mendefinisikan fungsi kerugian
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
labels=self.y, logits=self.logits)
self.loss = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate = lr)
self.train = optimizer.minimize(self.loss)
correct_prediction = tf.equal(tf.argmax(self.logits, 1),
tf.argmax(self.y, 1))
self.accuracy = tf.reduce_mean(tf.cast(correct_prediction,
tf.float32))
init = tf.global_variables_initializer()
143
self.sess = tf.Session()
self.sess.run(init)
self.saver = tf.train.Saver()
3. Metode model adalah metode di mana grafik arsitektur jaringan
konvolusional sebenarnya dibangun. Kita menggunakan fungsi
TensorFlow tf.nn.conv2d untuk membangun lapisan
konvolusional. Fungsi ini mengambil argumen yang didefinisikan
matriks filter sebagai bobot dan menghitung konvolusi antara
masukkan dan matriks filter. Kita juga menggunakan bias untuk
memberi kita kebebasan yang tinggi. Setelah dua lapisan
konvolusi, kita meratakan keluaran dan meneruskannya ke
lapisan yang sepenuhnya terhubung, ditunjukkan sebagai
berikut.
def model(self,x):
# Membuat Arsitektur
keep_prob = 0.7
# Lapisan 1: Konvolusional.
# Filter 5x5 num_filters = 6 Input_depth = 1
conv1_W = tf.Variable(tf.truncated_normal(shape=(5, 5, 1, 6), \
mean = self.mu, stddev = self.sigma))
conv1_b = tf.Variable(tf.zeros(6))
conv1 = tf.nn.conv2d(x, conv1_W, strides=[1, 1, 1, 1],
144
padding='VALID') + conv1_b
conv1 = tf.nn.relu(conv1)
# Max Pool 1
self.conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1],\
strides=[1, 2, 2, 1], padding='VALID')
# Lapisan 2: Konvolusional.
# Filter 5x5 num_filters = 16 Input_depth = 6
conv2_W = tf.Variable(tf.truncated_normal(shape=(5, 5, 6, 16), \
mean = self.mu, stddev = self.sigma))
conv2_b = tf.Variable(tf.zeros(16))
conv2 = tf.nn.conv2d(self.conv1, conv2_W, strides=[1, 1, 1, 1],\
padding='VALID') + conv2_b
conv2 = tf.nn.relu(conv2)
# Max Pool 2.
self.conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], \
strides=[1, 2, 2, 1], padding='VALID')
# Flatten.
145
fc0 = flatten(self.conv2)
print("x shape:",fc0.get_shape())
# Lapisan 3: Terkoneksi penuh.
# Input = fc0.get_shape[-1]. Output = 120.
fc1_W = tf.Variable(tf.truncated_normal(shape=(256, 120), \
mean = self.mu, stddev = self.sigma))
fc1_b = tf.Variable(tf.zeros(120))
fc1 = tf.matmul(fc0, fc1_W) + fc1_b
fc1 = tf.nn.relu(fc1)
# Dropout
x = tf.nn.dropout(fc1, keep_prob)
# Lapisan 4: Terkoneksi penuh.
# Input = 120. Output = 84.
fc2_W = tf.Variable(tf.truncated_normal(shape=(120, 84), \
mean = self.mu, stddev = self.sigma))
fc2_b = tf.Variable(tf.zeros(84))
fc2 = tf.matmul(x, fc2_W) + fc2_b
146
fc2 = tf.nn.relu(fc2)
# Dropout
x = tf.nn.dropout(fc2, keep_prob)
# Lapisan 6: Terkoneksi penuh.
# Input = 120. Output = n_classes.
fc3_W = tf.Variable(tf.truncated_normal(shape=(84, self.n), \
mean = self.mu, stddev = self.sigma))
fc3_b = tf.Variable(tf.zeros(self.n))
logits = tf.matmul(x, fc3_W) + fc3_b
#logits = tf.nn.softmax(logits)
return logits
4. Metode fit melakukan pelatihan secara batch, dan metode
predict memberikan keluaran untuk masukkan yang diberikan,
seperti yang ditunjukkan pada kode berikut.
def fit(self,X,Y,X_val,Y_val,epochs=10, batch_size=100):
X_train, y_train = X, Y
num_examples = len(X_train)
l = []
147
val_l = []
max_val = 0
for i in range(epochs):
total = 0
# Memplajari Batch wise
for offset in range(0, num_examples, batch_size):
end = offset + batch_size
batch_x, batch_y = X_train[offset:end], y_train[offset:end]
_, loss = self.sess.run([self.train,self.loss], \
feed_dict={self.x: batch_x, self.y: batch_y})
total += loss
l.append(total/num_examples)
accuracy_val = self.sess.run(self.accuracy, \
feed_dict={self.x: X_val, self.y: Y_val})
accuracy = self.sess.run(self.accuracy, feed_dict={self.x: X,
self.y: Y})
loss_val = self.sess.run(self.loss,
feed_dict={self.x:X_val,self.y:Y_val})
val_l.append(loss_val)
148
print("EPOCH {}/{} loss is {:.3f} training_accuracy {:.3f}\
andvalidation accuracy is {:.3f}".\
format(i+1,epochs,total/num_examples, accuracy,
accuracy_val))
# Menyimpan model dengan akurasi validari terbaik
if accuracy_val> max_val:
save_path = self.saver.save(self.sess, "/tmp/lenet1.ckpt")
print("Model saved in path: %s" % save_path)
max_val = accuracy_val
# Mengembalikan model terbaik
self.saver.restore(self.sess, "/tmp/lenet1.ckpt")
print("Restored model with highest validation accuracy")
accuracy_val = self.sess.run(self.accuracy,
feed_dict={self.x: X_val, self.y: Y_val})
accuracy = self.sess.run(self.accuracy,
feed_dict={self.x: X, self.y: Y})
return l,val_l, accuracy, accuracy_val
149
def predict(self, X):
return self.sess.run(self.logits,feed_dict={self.x:X})
5. Kita menggunakan kumpulan data angka tulisan tangan dan
mengunduhnya dari Kaggle (https://www.kaggle.com/c/digit-
recognizer/data). Kumpulan data tersedia dalam format .csv. Kita
memuat berkas .csv dan memproses data sebelumnya. Berikut
ini adalah contoh gambar pelatihan.
def load_data():
# Membaca data dan membuat set data latih, validasi dan tes
data = pd.read_csv('train.csv')
# Ini akan memastikan selalu 80% data adalah latih dan
# sisanya merupakan data validasi dengan np.random
train = data.sample(frac=0.8, random_state=255)
val = data.drop(train.index)
test = pd.read_csv('test.csv')
return train, val, test
def create_data(df):
labels = df.loc[:]['label']
y_one_hot = pd.get_dummies(labels).astype(np.uint8)
150
y = y_one_hot.values # One Hot encode the labels
x = df.iloc[:,1:].values
x = x.astype(np.float)
# Normalisasi data
x = np.multiply(x, 1.0 / 255.0)
# mengembalikan setiap gambar dengan deimensi 96 x 96 x 1
x = x.reshape(-1, 28, 28, 1)
return x,y
train, val, test = load_data()
X_train, y_train = create_data(train)
X_val, y_val = create_data(val)
X_test = (test.iloc[:,:].values).astype(np.float)
X_test = np.multiply(X_test, 1.0 / 255.0)
# mengembalikan setiap gambar dengan deimensi 96 x 96 x 1
X_test = X_test.reshape(-1, 28, 28, 1)
# Plot subset data latih
x_train_subset = X_train[:12]
# visualisasi subset dari latih data
151
fig = plt.figure(figsize=(20,2))
for i in range(0, len(x_train_subset)):
ax = fig.add_subplot(1, 12, i+1)
ax.imshow(x_train_subset[i].reshape(28,28), cmap='gray')
fig.suptitle('Subset of Original Training Images', fontsize=20)
plt.show()
Gambar 29. Subset datara gambar asli untuk latih
Di sini kita akan melatih modelnya.
n_train = len(X_train)
# Jumlah dari contoh validasi
n_validation = len(X_val)
# Jumlah dari contoh tes
n_test = len(X_test)
# Apa bantuk dari angka yang ditulis?
152
image_shape = X_train.shape[1:-1]
# Berapa banyak label yang ada di set data
n_classes = y_train.shape[-1]
print("Number of training examples =", n_train)
print("Number of Validation examples =", n_validation)
print("Number of testing examples =", n_test)
print("Image data shape =", image_shape)
print("Number of classes =", n_classes)
# Hasil
# Number of training examples = 33600
# Number of Validation examples = 8400
# Number of testing examples = 28000
# Image data shape = (28, 28)
# Number of classes = 10
# Define the data values
d = image_shape[0]
n = n_classes
153
from sklearn.utils import shuffle
X_train, y_train = shuffle(X_train,y_train)
6. Kita membuat objek LeNet dan melatihnya pada data pelatihan.
Hasil yang diperoleh adalah 99.658% pada set data latih dan
98.607% pada set data validasi.
# Create the Model
my_model = my_LeNet(d, n)
### Train model here.
loss, val_loss, train_acc, val_acc = my_model.fit(X_train, \
y_train, X_val, y_val, epochs=50)
Impresif! Anda dapat memprediksi masukkan untuk set data pengujian dan
mengirimkannya ke Kaggle.
4.4. Recurrent neural networks
Model yang telah kita pelajari sampai sekarang hanya menanggapi
masukan yang ada. Anda memberi mereka masukan, dan berdasarkan apa
yang telah mereka pelajari, mereka memberi Anda keluaran yang sesuai.
154
Tapi ini bukan cara kita sebagai manusia bekerja. Saat Anda membaca
kalimat, Anda tidak menafsirkan setiap kata satu per satu, Anda
mempertimbangkan kata-kata sebelumnya untuk menyimpulkan makna
semantiknya.
Gambar 30. Representasi dari jaringan syaraf berulang
RNN atau jaringan syaraf berulang dapat mengatasi masalah ini.
Mereka menggunakan putaran umpan balik, yang menyimpan informasi.
Putaran umpan balik memungkinkan informasi diteruskan dari langkah
sebelumnya hingga saat ini. Gambar 30 menunjukkan arsitektur dasar RNN
dan bagaimana umpan balik memungkinkan penerusan informasi dari satu
langkah jaringan ke langkah berikutnya (Unroll):
Pada Gambar 30 sebelumnya, X mewakili masukkan. Lapisan ini
terhubung ke neuron di lapisan tersembunyi dengan bobot Whx, keluaran
dari lapisan tersembunyi, h, diumpankan kembali kelapisan tersembunyi
155
melalui bobot Whh, dan juga berkontribusi pada keluaran, O, melalui
bobotWyh. Kita dapat menuliskan hubungan matematis sebagai berikut.
Dimana g adalah fungsi aktivasi, bh danby masing-masing adalah bias
dari neuron tersembunyi dan keluaran. Dalam hubungan sebelumnya,
semua X, h, dan O adalah vektor, sedangkanWhx, Whh, dan Wyh adalah
matriks. Dimensi masukkanX dan keluaranO tergantung pada set data yang
Anda kerjakan, dan jumlah unit lapisan tersembunyi h ditentukan oleh Anda.
Anda akan menemukan banyak makalah di mana peneliti telah
menggunakan 128 jumlah unit tersembunyi. Arsitektur sebelumnya hanya
menampilkan satu lapisan tersembunyi, tetapi kita dapat memiliki lapisan
tersembunyi sebanyak yang kita inginkan.
RNN telah diterapkan di bidang pemrosesan bahasa alami, juga
diterapkan untuk menganalisis data deret waktu, seperti harga saham.RNN
belajar melalui algoritma yang disebut sebagai propagasi mundur melalui
waktu atau Back Propagation Through Time (BPTT). Metoda ini adalah
modifikasi dari algoritma propagasi mundur yang memperhitungkan sifat
data deret waktu. Di sini, kerugian didefinisikan sebagai jumlah dari semua
fungsi kerugian pada waktu t = 1 hingga t = T (jumlah langkah waktu untuk
membuka gulungan), misalnya sebuah persamaan.
156
Di mana L(t) adalah kerugian pada waktu t, kita menerapkan aturan
rantai diferensiasi seperti sebelumnya, dan mendapatkan pembaruan bobot
untuk bobot Whx, Whh, dan Wyh.
TensorFlow menyediakan implementasi untuk RNN dan BPTT.
Namun bagi para pembaca yang tertarik untuk mendalami matematika,
berikut ini adalah beberapa referensi:
• Tentang kesulitan pelatihan Jaringan Saraf Rekuren, Razvan
Pascanu, Tomas Mikolov, dan Bengio
(https://arxiv.org/pdf/1211.5063.pdf)
• Mempelajari Ketergantungan Jangka Panjang dengan Penurunan
Gradien Sulit, Yoshua Bengio, Patrice dan Paolo Frasconi
(www.iro.umontreal.ca/~lisa/pointeurs/ieeetrnn94.pdf)
Kita menyajikan RNN dengan satu masukan untuk setiap langkah
waktu dan memprediksi keluaran yang sesuai. BPTT bekerja dengan
membuka semua langkah waktu masukkan. Kesalahan dihitung dan
diakumulasikan untuk setiap langkah, kemudian jaringan digulung kembali
untuk memperbaruibobot. Salah satu kelemahan BPTT adalah ketika jumlah
langkah waktu bertambah, penghitungan juga meningkat. Hal ini membuat
model keseluruhan menjadi mahal secara komputasi. Selain itu, karena
beberapa perkalian gradien, jaringan rentan terhadap masalah gradien yang
menghilang.
157
Untuk mengatasi masalah ini, pada versi BPTT yang dimodifikasi atau
pada metode BPTT-yang-terpotong sering digunakan. Dalam BPTT yang
terpotong, data diproses satu langkah pada satu waktu dan pembaruan
berat BPTT dilakukan secara berkala untuk beberapa langkah waktu
tertentu.Kita dapat menghitung langkah-langkah dari algoritma BPTT yang
terpotong sebagai berikut.
1. Sajikan urutan langkah waktu K1 dari pasangan masukkan dan
keluaran ke jaringan
2. Hitung dan kumpulkan kesalahan di seluruh langkah waktu K2
dengan membuka gulungan jaringan
3. Perbarui bobot dengan menggulung jaringan
Performa algoritma bergantung pada dua hyperparameterK1 dan K2.
Jumlah langkah penerusan waktu antara pembaruan diwakili oleh K1, ini
mempengaruhi seberapa cepat atau lambat pelatihan akan dilakukan dan
frekuensi pembaruan beban. K2 di sisi lain, mewakili jumlah langkah waktu
ituberlaku untuk BPTT, itu harus cukup besar untuk menangkap struktur
temporal dari data masukan.
4.4.1. Long short-term memory
Hochreiter dan Schmidhuber pada tahun 1997 mengusulkan model
RNN yang dimodifikasi yang disebut long short-term memory (LSTM)
158
sebagai solusi untuk mengatasi masalah menghilangnya gradien. Lapisan
tersembunyi di RNN diganti dengan sel LSTM.
Sel LSTM terdiri dari tiga gerbang, gerbang lupa (forget gate),
gerbang masukan (input gate), dan gerbang keluaran (output gate).
Gerbang ini mengontrol jumlah memori jangka panjang dan memori jangka
pendek yang dihasilkan dan dipertahankan oleh sel. Semua gerbang
memiliki fungsi sigmoid, yang memadatkan masukkan antara 0 dan 1.
Setelah itu, kita melihat bagaimana keluaran dari berbagai gerbang dihitung,
jika ekspresi tampak menakutkan bagi Anda, jangan khawatir, kita akan
menggunakan kelas dalam pustaka dari TensorFlow yakni
tf.contrib.rnn.BasicLSTMCell dan tf.contrib.rnn.static_rnn untuk
mengimplementasikan sel LSTM. Representasi dari cara kerja LSTM di
ilustrasikan pada Gambar 31.
Gambar 31. Sel LSTM dasar, x adalah masukan ke sel, h memori jangka pendek dan c
memori jangka panjang, ke semuanya subskrip mengacu pada waktu
159
Pada setiap langkah waktu, t, sel LSTM mengambil tiga masukkan:
masukkan xt, memori jangka pendek ht-1, dan memori jangka panjang ct-1.
Juga mengeluarkan memori jangka panjang ct dan memori jangka pendek ht.
Subskrip ke x, h, dan c merujuk ke langkah waktu atau timestep.
Forget Gatef(.) mengendalikan jumlah memori jangka pendek, h,
yang harus diingat untuk aliran lebih lanjut dalam langkah waktu sekarang.
Secara matematis kita dapat merepresentasikan Forget Gatef(.) sebagai
berikut.
Di mana variabelσ mewakili fungsi aktivasi sigmoid, Wfx dan Wfh adalah
bobot yang mengontrol pengaruh masukkanxt, memori jangka pendek ht-1,
dan bf yang merupakan bias dari gerbang lupa.
Input gate i(.) mengendalikan jumlah masukkan dan memori kerja yang
mempengaruhi keluaran sel. Kita dapat mengungkapkannya sebagai
persamaan berikut ini.
Output gateo(.) mengendalikan jumlah informasi yang digunakan untuk
memperbarui memori jangka pendek, dan diberikan sebagai berikut.
160
Selain ketiga gerbang ini, sel LSTM juga menghitung status kandidat
tersembunyi , yang bersama dengan gerbang masukan dan lupa, digunakan
untuk menghitung jumlah ct memori jangka panjang.
Lingkaran melambangkan perkalian bijak elemen atau the element wise
multiplication. Nilai baru dari memori jangka pendek kemudian dihitung
sebagai persamaan berikut.
Sekarang mari kita lihat bagaimana kita dapat mengimplementasikan LSTM
di TensorFlow dalam langkah-langkah berikut.
1. Pertama kita mengimpor modul yang digunakan terlebih dahulu.
import tensorflow as tf
from tensorflow.contrib import rnn
import numpy as np
2. Kita mendefinisikan kelas LSTM di mana kita membuat grafik dan
menentukan lapisan LSTM dengan bantuan kontribusi TensorFlow.
Untuk menjaga memori, pertama-tama kita menghapus tumpukan
grafik default dan menyetel ulang grafik default global menggunakan
tf.reset_default_graph(). Masukan langsung menuju ke lapisan LSTM
161
dengan jumlah unit tersembunyi num_units. Ini diikuti oleh lapisan
keluaran yang terhubung sepenuhnya dengan bobot out_weights dan
bias out_bias. Buat placeholder untuk masukkanself.x dan label
self.y. Masukkan dibentuk ulang dan diumpankan ke sel LSTM.
Untuk membuat lapisan LSTM, pertama-tama kita mendefinisikan sel
LSTM dengan unit tersembunyi num_units dan melupakan bias yang
disetel ke 1.0. Hal ini menambah bias pada gerbang lupa untuk
mengurangi skala lupa di awal pelatihan. Bentuk kembali keluaran
dari lapisan LSTM dan masukkan ke lapisan yang sepenuhnya
terhubung (fully connected layer), seperti berikut.
class LSTM:
def __init__(self, num_units, n_classes, n_input,\
time_steps, learning_rate=0.001,):
tf.reset_default_graph()
self.steps = time_steps
self.n = n_input
# bobot dan bias dari bentuk yang sesuai
out_weights = tf.Variable(tf.random_normal([num_units, n_classes]))
out_bias = tf.Variable(tf.random_normal([n_classes]))
# mendefinisikan placeholders
162
# placeholder masukkan
self.x = tf.placeholder("float", [None, self.steps, self.n])
# label placeholder
self.y = tf.placeholder("float", [None, n_classes])
# memproses maukan tensor dari [batch_size,steps,self.n] ke
# jumlah “steps” tensor [batch_size,self.n]
input = tf.unstack(self.x, self.steps, 1)
# mendefinisikan jaringan
lstm_layer = rnn.BasicLSTMCell(num_units, forget_bias=1)
outputs, _ = rnn.static_rnn(lstm_layer, input, dtype="float32")
# mengkonversi masukkan terakhir dimensi [batch_size,num_units]
# ke [batch_size,n_classes] dengan perkalian out_weight
self.prediction = tf.matmul(outputs[-1], out_weights) + out_bias
# loss_function
self.loss = tf.reduce_mean(tf.squared_difference(
163
self.prediction, self.y))
# optimization
self.opt = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(self.loss)
# evaluasi model
correct_prediction = tf.equal(tf.argmax(self.prediction, 1),
tf.argmax(self.y, 1))
self._accuracy = tf.reduce_mean(tf.cast(correct_prediction,
tf.float32))
init = tf.global_variables_initializer()
gpu_options = tf.GPUOptions(allow_growth=True)
self.sess = tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options))
self.sess.run(init)
3. Kita membuat metode untuk melatih dan memprediksi, seperti yang
ditunjukkan pada kode berikut.
def train(self, X, Y, epochs=100,batch_size=128):
iter = 1
X = X.reshape((len(X),self.steps,self.n))
164
while iter &lt; epochs:
for i in range(int(len(X)/batch_size)):
batch_x, batch_y = X[i:i+batch_size,:], Y[i:i+batch_size,:]
self.sess.run(self.opt,
feed_dict={self.x: batch_x, self.y: batch_y})
if iter % 10 == 0:
acc = self.sess.run(self._accuracy,
feed_dict={self.x: X, self.y: Y})
los = self.sess.run(self.loss,
feed_dict={self.x: X, self.y: Y})
print("For iter ", iter)
print("Accuracy ", acc)
print("Loss ", los)
print("__________________")
iter = iter + 1
def predict(self,X):
# memprediksi keluaran
test_data = X.reshape((-1, self.steps, self.n))
out = self.sess.run(self.prediction,
165
feed_dict={self.x:test_data})
return out
4.4.2. Gated recurrent unit
Gated recurrent unit(GRU) adalah modifikasi lain dari RNN. Ini
memiliki arsitektur yang disederhanakan dibandingkan dengan LSTM dan
mengatasi masalah gradien yang hilang. Hanya dibutuhkan dua masukkan,
yaitu masukkanxt pada waktu t dan memori ht-1 dari waktu t-1. Hanya ada
dua gerbang, Gerbang Pembaruan atau Update Gate dan Gerbang Atur
Ulang atau Reset Gate, ditunjukkan pada Gambar 32 berikut.
Gambar 32. Arsitektur dasar dari sel GRU
166
Gerbang pembaruan mengendalikan berapa banyak memori sebelumnya
yang harus disimpan, dan gerbang reset menentukan cara menggabungkan
masukkan baru dengan memori sebelumnya. Kita dapat menentukan sel
GRU lengkap dengan empat persamaan berikut.
•
•
•
•
Baik GRU dan LSTM memberikan kinerja yang sebanding, tetapi GRU
memiliki parameter pelatihan yang lebih sedikit.
4.5. Autoencoders
Model yang kita pelajari selama ini adalah pembelajaran dengan
supervised learning atau pembelajaran yang diawasi. Kali ini kita akan
belajar tentang autoencoder. Autoencodersmerupakan umpan maju
ataufeedforward, jaringan saraf non-berulang atau non-recurrent neural
network, dan belajar melalui pembelajaran tanpa pengawasan atau
unsupervised learning. Mereka adalah buzzword terbaru, bersama dengan
jaringan permusuhan generatif, dan kita dapat menemukan aplikasi dalam
rekonstruksi gambar, pengelompokan, terjemahan mesin, dan banyak lagi.
Mereka awalnya mengusulkan metode ini pada tahun 1980-an oleh
167
Geoffrey E. Hinton dan kelompok PDP yang ada pada laman berikut
(http://www.cs.toronto.edu/~fritz/absps/clp.pdf).
Autoencoder pada dasarnya terdiri dari dua jaringan neural
bertingkat, jaringan pertama bertindak sebagai encoder,hal ini mengambil
masukkanx dan mengkodekannya menggunakan transformasi h menjadi
sinyal yang dikodekan y, ditunjukkan dalam persamaan berikut.
Jaringan saraf kedua menggunakan sinyal yang dikodekan y sebagai
masukkannya dan melakukan transformasi lainf untuk mendapatkan sinyal r
yang direkonstruksi, yang ditunjukkan sebagai berikut.
Fungsi kerugian adalah MSE dengan kesalahan e didefinisikan
sebagai perbedaan antara masukkan asli x dan sinyal yang direkonstruksi r.
Pada Gambar 33 menunjukkan autoencoderdengan Encoder dan
Decoderyang disorot secara terpisah. Autoencoder mungkin memiliki
pembagian bobot, yaitu bobot decoder dan encoder dibagikan. Ini dilakukan
hanya dengan membuat mereka saling bertukar posisi.Hal ini membantu
jaringan belajar lebih cepat karena jumlah parameter pelatihan lebih sedikit.
Ada berbagai macam autoencoder misalnya: autoencodersparse,
autoencoderdenoising, autoencoder konvolusi, dan autoencoder variasional.
168
Gambar 33. Arsitektur dasar dari autoencoder
4.5.1. Denoisingautoencoders
Denoising autoencoder belajar dari masukkan yang rusak (noisy).Kita
memberi umpan jaringan encodermasukkannoisy dan gambar yang
direkonstruksi dari decoder dibandingkan dengan masukkan denoisasi asli.
Idenya adalah ini akan membantu jaringan mempelajari cara menolak
masukan. Jaringan tidak hanya membuat perbandingan berdasarkan piksel,
melainkan, untuk menghilangkan gangguan gambar (image denoising),
jaringan juga dipaksa untuk mempelajari informasi piksel tetangga.
169
Setelah autoencoder mempelajari fitur yang dikodekan y, kita dapat
menghapus bagian decoder dari jaringan dan hanya menggunakan bagian
encoder untuk mencapai pengurangan dimensi. Masukkan yang direduksi
secara dimensional dapat diumpankan ke beberapa klasifikasi atau model
regresi lainnya.
4.5.2. Variational autoencoders
Autoencoder lain yang sangat populer adalah variational
autoencoders (VAE). Metoda ini merupakan campuran yang terbaik dari
kedua dunia, Deep Learning dan inferensi Bayesian.
VAE memiliki lapisan stokastik tambahan. Lapisan ini ada setelah
jaringan encoder, mengambil sampel data menggunakan distribusi Gaussian,
dan lapisan setelah jaringan decoder mengambil sampel data menggunakan
distribusi Bernoulli.
VAE dapat digunakan untuk menghasilkan gambar. VAE
memungkinkan seseorang untuk menetapkan prior kompleks dalam laten
dan mempelajari representasi laten yang kuat. Kita akan belajar lebih
banyak tentang mereka di bab selanjutnya.
170
4.6. Kesimpulan
Pada bagian ini, kita membahas beberapa model jaringan saraf
dalam atau deep neural network dasar dan juga berguna. Kita mulai dengan
satu neuron, melihat kekuatannya dan keterbatasannya. Perceptron
berlapis-lapis atau Multilayer Preceptrons dibangun untuk tugas regresi dan
klasifikasi. Algoritma propagasi mundur diperkenalkan. Pada bagian ini
berlanjut ke CNN, dengan pengantar ke lapisan konvolusi dan lapisan
penyatuan.
Kita juga telah belajar tentang beberapa contoh CNN yang sukses
dan menggunakan CNN LeNet pertama untuk melakukan pengenalan angka
tulisan tangan. Dari umpan maju MLP dan CNN, kita pindah mempelajari ke
RNN. Jaringan LSTM dan GRU diperkenalkan. Kita membuat jaringan LSTM
kita sendiri di TensorFlow dan akhirnya mempelajari tentang pembuat kode
otomatis.
204
Daftar Pustaka
Buku dan Artikel Ilmiah
Kapoor, A. (2019) Hands-On Artificial Intelligence for IoT: Expert machine learning and deep learning techniques for developing smarter IoT systems.
Kapoor, A. and Fandango, A. (2018) TensorFlow Machine Learning Projects: Build 13 real-world projects with advanced numerical computations using the Python ecosystem.
Piccialli, F., Bessis, N. and Jung, J. (2020) ‘Data Science challenges in Industry 4.0’, IEEE Transactions on Industrial Informatics, PP, p. 1. doi: 10.1109/TII.2020.2984061.
Soni, N. et al. (2020) ‘Artificial Intelligence in Business: From Research and Innovation to Market Deployment’, Procedia Computer Science, 167, pp. 2200–2210. doi: 10.1016/j.procs.2020.03.272.
Laman internet
6.2. Convolutions for Images — Dive into Deep Learning 0.14.3 documentation. Tersedia pada laman: https://d2l.ai/chapter_convolutional-neural-networks/conv-layer.html.
7 Types of Activation Functions in Neural Networks: How to Choose?. Tersedia pada laman: https://missinglink.ai/guides/neural-network-concepts/7-types-neural-network-activation-functions-right/.
Activation Functions — ML Glossary documentation. Tersedia pada laman: https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html.
CS231n Convolutional Neural Networks for Visual Recognitio. Tersedia pada laman: https://cs231n.github.io/neural-networks-1/.
205
Leaky rectified linear unit (Leaky ReLU) (no date). Available at: http://interstellarengine.com/ai/Leaky-ReLU.html).
sklearn.tree.DecisionTreeClassifier — scikit-learn 0.23.2 documentation. Tersedia pada laman:https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html?highlight=decisiontreeclassifie#sklearn.tree.DecisionTreeClassifier.
1
Biodata
Novi Azman, S.T., M.T.
Pendidikan Strata-1 di jurusan Teknik Elektro di Univesitas Nasional diselesaikan pada tahun 2000. Kemudian Melanjutkan pendidikan Strata-2 di Universitas Indonesia dengan jurusan yang sama, yakni Teknik Elektro pada tahun 2005. Penulis berpengalaman dalam bidang Desain Rangkaian Logika, Telekomunikasi dan Teknik Biomedis terutama dalam Telemonitoring atau Health Internet of Things. Saat ini penulis merupakan dosen Teknik Elektro dan Wakil Dekan Fakultas Teknik dan Sains di Universitas Nasional.