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


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

http://archive.ics.uci.edu/ml/datasets/combined+cycle+power+plant

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.

https://www.kaggle.com/c/predict-impact-of-air-quality-on-death-rates

https://www.kaggle.com/c/predict-impact-of-air-quality-on-death-rates

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

https://deeplearing.ai/

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.

https://www.technologyreview.com/s/603062/ai-winter-isnt-coming/

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:

http://www.columbia.edu/~ahd2125/post/2015/12/5/

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 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 < 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)



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 < 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


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).

http://yann.lecun.com/exdb/lenet/

http://www.robots.ox.ac.uk/~vgg/research/very_deep/

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.

http://yann.lecun.com/exdb/publis/pdf/jackel-95.pdf

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))


143


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), \


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), \


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)


# Input = 120. Output = 84.

fc2_W = tf.Variable(tf.truncated_normal(shape=(120, 84), \


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)


# Input = 120. Output = n_classes.

fc3_W = tf.Variable(tf.truncated_normal(shape=(84, self.n), \


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


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)

https://www.kaggle.com/c/digit-recognizer/data

https://www.kaggle.com/c/digit-recognizer/data

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.

https://arxiv.org/pdf/1211.5063.pdf

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.


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))


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 < 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,


los = self.sess.run(self.loss,


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.

http://www.cs.toronto.edu/~fritz/absps/clp.pdf

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


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.

internet of things dan kecerdasan buatanrepository.unas.ac.id/2269/1/buku pertama upload.pdf ·...

Documents