Pembelajaran Mendalam Dengan Aplikasi Menggunakan Python

Halaman 1
Pembelajaran Mendalam
dengan Aplikasi
Menggunakan Python
Chatbots dan Wajah, Objek, dan Ucapan
Pengakuan Dengan TensorFlow dan Keras
—
Navin Kumar Manaswi
Halaman 2
Pembelajaran Mendalam dengan
Aplikasi Menggunakan
Python
Chatbots dan Wajah, Objek,
dan Pengenalan Ucapan
Dengan TensorFlow dan Keras
Navin Kumar Manaswi
halaman 3
Pembelajaran Mendalam dengan Aplikasi Menggunakan Python

Navin Kumar Manaswi
Bangalore, Karnataka, India
ISBN-13 (pbk): 978-1-4842-3515-7 ISBN-13 (elektronik): 978-1-4842-3516-4

https://doi.org/10.1007/978-1-4842-3516-4
Nomor Kontrol Perpustakaan Kongres: 2018938097
Hak Cipta © 2018 oleh Navin Kumar Manaswi

Karya ini tunduk pada hak cipta. Semua hak dilindungi oleh Penerbit, baik seluruhnya atau
bagian dari materi yang bersangkutan, khususnya hak penerjemahan, pencetakan ulang, penggunaan kembali
ilustrasi, pembacaan, penyiaran, reproduksi pada mikrofilm atau dengan cara fisik lainnya,
dan transmisi atau penyimpanan dan pengambilan informasi, adaptasi elektronik, perangkat lunak komputer,
atau dengan metodologi serupa atau berbeda yang sekarang dikenal atau dikembangkan selanjutnya.
Nama merek dagang, logo, dan gambar mungkin muncul di buku ini. Daripada menggunakan merek dagang
simbol dengan setiap kemunculan nama merek dagang, logo, atau gambar, kami menggunakan nama, logo,
dan gambar hanya dalam gaya editorial dan untuk kepentingan pemilik merek dagang, tanpa
maksud pelanggaran merek.
Penggunaan nama dagang, merek dagang, merek layanan, dan istilah serupa dalam publikasi ini, meskipun
mereka tidak diidentifikasi seperti itu, tidak untuk dianggap sebagai ekspresi pendapat mengenai apakah atau tidak
mereka tunduk pada hak milik.
Sedangkan nasehat dan informasi dalam buku ini diyakini benar dan akurat pada tanggal
publikasi, baik penulis maupun editor maupun penerbit tidak dapat menerima hukum apa pun
bertanggung jawab atas kesalahan atau kelalaian yang mungkin dilakukan. Penerbit tidak memberikan jaminan,
tersurat maupun tersirat, sehubungan dengan materi yang terkandung di sini.
Managing Director, Apress Media LLC: Welmoed Spahr

Editor Akuisisi: Celestin Suresh John
Editor Pengembangan: Matthew Moodie
Editor Koordinator: Divya Modi
Sampul dirancang oleh eStudioCalamar
Gambar sampul didesain oleh Freepik (www.freepik.com)
Didistribusikan ke perdagangan buku di seluruh dunia oleh Springer Science+Business Media New York,
233 Spring Street, Lantai 6, New York, NY 10013. Telepon 1-800-SPRINGER , faks (201) 348-4505 ,
e-mail orders-ny@springer-sbm.com, atau kunjungi www.springeronline.com. Apress Media, LLC adalah
California LLC dan satu-satunya anggota (pemilik) adalah Springer Science + Business Media Finance Inc
(SSBM Keuangan Inc). SSBM Finance Inc adalah perusahaan Delaware .
Untuk informasi tentang terjemahan, silakan kirim email ke rights@apress.com, atau kunjungi www.apress.com/
hak-izin.
Judul Apress dapat dibeli dalam jumlah besar untuk penggunaan akademis, perusahaan, atau promosi. eBuku
versi dan lisensi juga tersedia untuk sebagian besar judul. Untuk informasi lebih lanjut, referensi Cetak kami
dan halaman web Penjualan Massal eBook di www.apress.com/bulk-sales.
Setiap kode sumber atau materi tambahan lainnya yang dirujuk oleh penulis dalam buku ini adalah
tersedia untuk pembaca di GitHub melalui buku ' s halaman produk, yang terletak di www.apress.
com/9781484235157. Untuk informasi lebih rinci, silakan kunjungi www.apress.com/source-code.
Dicetak pada kertas bebas asam
halaman 4
Daftar isi
Kata Pengantar ................................................... .................................................ix
Tentang Penulis ............................................... .................................xi
Tentang Peninjau Teknis .................................................. .............xiii
Bab 1: Dasar-dasar TensorFlow ............................................ .............1

Tensor ................................................................... ................................................................... ............... 2
Grafik Komputasi dan Sesi .................................................. ..........................3
Konstanta, Placeholder, dan Variabel ............................................ ....................6
Tempat penampung ................................................................. ................................................................... ...... 9
Membuat Tensor ................................................... .................................................12

Tensor Tetap ................................................... .................................................13
Tensor Urutan ................................................................. ........................................14
Tensor Acak ................................................... ............................................ 15
Bekerja pada Matriks ................................................................... .................................................16
Fungsi Aktivasi ................................................................. .................................................17

Tangen Hiperbolik dan Sigmoid .................................................. .....................18
ReLU dan ELU ............................................................... ...................................................19
ReLU6 ................................................................... ................................................................... .........20
Fungsi Rugi ................................................................. ................................................................... .. 22

Contoh Fungsi Rugi ............................................................ .................................23
Fungsi Rugi Umum ........................................................ .................................23
aku aku aku
halaman 5
DAFTAR ISI
Pengoptimal ................................................... ................................................................... ........25

Contoh Fungsi Rugi ............................................................ .................................26
Pengoptimal Umum ................................................... .................................................27
Metrik ................................................................... ................................................................... .............28
Contoh Metrik ................................................... ........................................28
Metrik Umum ................................................................. .................................................29
Bab 2: Memahami dan Bekerja dengan Keras .........................31

Langkah-Langkah Utama untuk Model Pembelajaran Mendalam .................................................. ....................32
Muat Data ................................................... ................................................................... ....33
Praproses Data ................................................................... .................................................33
Tentukan Modelnya ............................................................... .................................................34
Kompilasi Modelnya ............................................................... .................................................36
Sesuaikan Modelnya ............................................................... ................................................................... .37
Evaluasi Model ................................................... ..................................................38
Prediksi ................................................... ................................................................... ... 38
Simpan dan Muat Ulang Model .................................................. .................................39
Opsional: Ringkas Model .................................................. ....................39
Langkah Tambahan untuk Memperbaiki Model Keras ............................................ .............40

Keras dengan TensorFlow ................................................... ........................................42
Bab 3: Perceptron Multilayer.................................................. ...........45

Jaringan Syaraf Tiruan ................................................................... ..................................45
Perceptron Lapisan Tunggal .................................................. .................................................47
Perceptron Multilayer ................................................................. .................................................47
Model Regresi Logistik ........................................................ ...................................49
iv
halaman 6
DAFTAR ISI
Bab 4: Regresi ke MLP di TensorFlow ........................................57

Langkah-Langkah TensorFlow untuk Membangun Model .................................................. .........................57
Regresi Linier di TensorFlow .................................................. ..........................58
Model Regresi Logistik ........................................................ ...................................62
Perceptron Multilayer di TensorFlow .................................................. ....................65
Bab 5: Regresi MLP di Keras .................................................. ....69

Model Log-Linear ........................................................ ................................................................... 69
Jaringan Saraf Keras untuk Regresi Linier ................................................ ..........71
Regresi logistik ................................................ ...................................................73

scikit-belajar untuk Regresi Logistik ............................................ ...................74
Jaringan Saraf Keras untuk Regresi Logistik ............................................ ..74
Data Fashion MNIST: Regresi Logistik di Keras .......................................77
MLP pada Data Iris .................................................. ...................................................80
Tulis Kodenya ............................................... .................................................80
Membangun Model Keras Berurutan .................................................. ........................81
MLP pada Data MNIST (Klasifikasi Digit) ........................................ ................84

MLP pada Data yang Dihasilkan Secara Acak .................................................. ....................88
Bab 6: Jaringan Saraf Konvolusi .........................................91

Lapisan berbeda dalam CNN ............................................................ .................................................91
Arsitektur CNN ................................................................. ...................................................95
Bab 7: CNN di TensorFlow ............................................ ................97

Mengapa TensorFlow untuk Model CNN? ................................................................... ....................97
Kode TensorFlow untuk Membangun Pengklasifikasi Gambar untuk Data MNIST........................98
Menggunakan API Tingkat Tinggi untuk Membangun Model CNN ........................................ ......104
halaman 7
DAFTAR ISI
Bab 8: CNN di Keras ............................................ ....................105

Membangun Pengklasifikasi Gambar untuk Data MNIST di Keras ......................................105
Mendefinisikan Struktur Jaringan .................................................. ........................107
Mendefinisikan Model Arsitektur .................................................. ....................108
Membangun Pengklasifikasi Gambar dengan Data CIFAR-10 ......................................... ....110

Mendefinisikan Struktur Jaringan .................................................. ........................111
Mendefinisikan Model Arsitektur .................................................. .................................112

Model Pralatih ................................................................. ..................................................113
Bab 9: RNN dan LSTM ............................................ .....................115

Konsep RNN ............................................................ ........................................115
Konsep LSTM .................................................................. ................................................118
Mode LSTM ................................................................... ................................................................... 118
Prediksi Urutan ................................................................. ........................................ 119

Prediksi Angka Urutan ............................................................ ......................120
Klasifikasi Urutan ................................................................. ..................................120
Pembuatan Urutan ................................................................. ..................................121
Prediksi Sequence-to-Sequence .................................................. ..................121
Peramalan Time-Series dengan Model LSTM ........................................ ......122
Bab 10: Ucapan ke Teks dan Sebaliknya ......................................127

Konversi Ucapan-ke-Teks ............................................ ...................................128
Ucapan sebagai Data ................................................................... ................................................................... 128
Fitur Pidato: Memetakan Pidato ke Matriks .................................................. ......129
Spektogram: Memetakan Ucapan ke Gambar .................................................. ........131
Membangun Pengklasifikasi untuk Pengenalan Ucapan Melalui Fitur MFCC .............132
Membangun Pengklasifikasi untuk Pengenalan Suara Melalui Spektogram .............133

Pendekatan Sumber Terbuka ............................................... ...................................135
vi
halaman 8
DAFTAR ISI
Contoh Menggunakan Setiap API .............................................. ....................................135
Menggunakan PocketSphinx ................................................... .....................................135
Menggunakan Google Speech API ........................................................ ..........................136
Menggunakan Google Cloud Speech API ............................................ .................137
Menggunakan API Wit.ai............................................ ................................................137
Menggunakan API Houndify .................................................................. ..................................138
Menggunakan IBM Speech to Text API .................................................. .....................138
Menggunakan API Pengenalan Suara Bing ............................................ ............... 139
Konversi Text-to-Speech ............................................ ...................................140

Menggunakan pyttsx ................................................... ..................................................140
Menggunakan SAPI ................................................... ................................................................... .140
Menggunakan SpeechLib ................................................... ........................................140
Kode Pemotongan Audio ........................................................ .................................................141
Penyedia Layanan Kognitif ................................................................... ...................................142
Microsoft Azure ................................................... .................................................143
Layanan Kognitif Amazon ................................................................... ..........................143
Layanan IBM Watson ................................................................... .....................................144
Masa Depan Analisis Ucapan ............................................................ ..................................144
Bab 11: Mengembangkan Chatbots .................................................. ........145

Mengapa Chatbot? ................................................................... ................................................... 146
Desain dan Fungsi Chatbots .................................................. .....................146
Langkah-Langkah Membangun Chatbot .................................................. ................................147

Prapemrosesan Teks dan Pesan .................................................. ................148
Pengembangan Chatbot Menggunakan API .................................................. .................166
Praktik Terbaik Pengembangan Chatbot .................................................. ...............169

Kenali Pengguna Potensial .................................................. ..................................169
Baca Sentimen Pengguna dan Jadikan Bot Memperkaya Emosional ..........169
vii
halaman 9
DAFTAR ISI
Bab 12: Deteksi dan Pengenalan Wajah ...................................171

Deteksi Wajah, Pengenalan Wajah, dan Analisis Wajah ...................................172
OpenCV................................................................. ................................................................... ...........172

Eigenface ................................................................... ................................................................... 173
LBPH ................................................... ................................................................... .........175
Nelayan ................................................................... .................................................176
Mendeteksi Wajah ........................................................ ................................................177
Melacak Wajah ............................................... ...................................................179
Pengenalan Wajah ................................................................... ..................................................182

Pengenalan Wajah Berbasis Pembelajaran Mendalam ................................................ ...............185
Pindah Belajar ................................................... ....................................................188

Mengapa Pindah Belajar? ................................................................... .................................188
Contoh Pembelajaran Transfer ................................................... ...........................189
Hitung Nilai Transfer .................................................. ..........................191
API ................................................................... ................................................................... ................197

Lampiran 1: Fungsi Keras untuk Pemrosesan Gambar .........................201
Lampiran 2: Beberapa Kumpulan Data Gambar Teratas yang Tersedia .................207
Lampiran 3: Pencitraan Medis: Format File DICOM .................................211

Mengapa DICOM? ................................................................... ................................................................... .211
Apa Format File DICOM? ................................................................... .....................211
Indeks ................................................... .................................................213
viii
halaman 10
Kata pengantar
Deep Learning telah berjalan sangat jauh. Dari lahirnya ide hingga
memahami pikiran manusia dan konsep asosiasionisme — bagaimana kita
mempersepsikan sesuatu dan bagaimana hubungan objek dan pandangan memengaruhi
berpikir dan melakukan, hingga model asosiasionisme yang dimulai pada tahun
tahun 1870-an ketika Alexander Bain memperkenalkan konser pertama Artificial
Neural Network dengan mengelompokkan neuron.
Maju cepat ke hari ini 2018 dan kita lihat bagaimana Deep Learning memiliki
ditingkatkan secara dramatis dan dalam semua bentuk kehidupan — mulai dari deteksi objek,
pengenalan suara, terjemahan mesin, kendaraan otonom, wajah
deteksi dan penggunaan deteksi wajah dari tugas-tugas duniawi seperti
membuka kunci iPhoneX Anda untuk melakukan tugas yang lebih mendalam seperti kejahatan
deteksi dan pencegahan.
Jaringan Saraf Konvolusi dan Jaringan Saraf Berulang
bersinar terang saat mereka terus membantu memecahkan masalah dunia
di semua bidang industri seperti Otomotif & Transportasi,
Kesehatan & Kedokteran, Ritel untuk beberapa nama. Kemajuan besar sedang dibuat
di area ini dan metrik seperti ini cukup menjelaskan tentang palpabilitas
industri pembelajaran mendalam:
– Jumlah makalah akademik Ilmu Komputer telah melonjak hingga hampir

10x sejak 1996
– VC berinvestasi 6x lebih banyak di startup AI sejak tahun 2000
– Ada 14x lebih banyak startup AI aktif sejak tahun 2000
– Pasar pekerjaan terkait AI mempekerjakan 5x lebih banyak sejak 2013 dan Deep Learning adalah
skill paling dicari di 2018
ix
halaman 11
KATA PENGANTAR
– 84% perusahaan percaya bahwa berinvestasi di AI akan memberi mereka persaingan yang hebat
tepi tive
Dan akhirnya,
– tingkat kesalahan klasifikasi gambar telah turun dari 28% pada tahun 2012 menjadi
2,5% di tahun 2017 dan terus turun!
Masih komunitas peneliti tidak puas. Kami mendorong

batas dan saya bergerak maju dengan rekan-rekan saya untuk mengembangkan model
di sekitar Jaringan Kapsul yang cerah dan berkilau dan berikan Pembelajaran Mendalam
tepi besar. Saya bukan satu-satunya dalam pertempuran ini. Dengan senang hati saya
berikan kata pengantar ini untuk Navin, seorang profesional yang dihormati di Deep Learning
komunitas yang saya kenal dengan baik.
Bukunya akan datang pada saat yang tepat. Industri juga
peserta didik membutuhkan sarana praktis untuk memperkuat pengetahuan mereka dalam
Deep Learning dan terapkan dalam pekerjaan mereka.
Saya yakin bahwa buku Navin akan memberi para pelajar apa yang mereka butuhkan.
TensorFlow semakin menjadi pemimpin pasar dan Keras juga
diadopsi oleh para profesional untuk memecahkan masalah sulit di komputer
visi dan NLP (Natural Language Processing). Tidak ada satu pun
perusahaan di planet ini yang tidak berinvestasi di dua area aplikasi ini.
Saya menantikan buku ini diterbitkan dan akan menjadi yang pertama dalam antrean
untuk mendapatkan. Dan saran saya untuk Anda adalah: Anda juga harus!
halaman 12
tentang Penulis
Navin Kumar Manaswi telah berkembang
Solusi AI dengan penggunaan mutakhir
teknologi dan ilmu pengetahuan yang berhubungan dengan artifisial
kecerdasan selama bertahun-tahun. Setelah bekerja untuk
perusahaan konsultan di Malaysia, Singapura,
dan proyek Dubai Smart City, juga
sebagai perusahaannya sendiri, ia telah mengembangkan
campuran keterampilan yang langka untuk menyampaikan ujung ke ujung
solusi kecerdasan buatan, termasuk
kecerdasan video, kecerdasan dokumen, dan
chatbot mirip manusia. Saat ini, ia memecahkan masalah B2B secara vertikal
perawatan kesehatan, aplikasi perusahaan, IoT industri, dan ritel di Symphony
AI Incubator sebagai arsitek AI pembelajaran yang mendalam. Dengan buku ini, dia ingin
mendemokratisasikan komputasi kognitif dan layanan untuk semua orang, terutama
pengembang, ilmuwan data, insinyur perangkat lunak, insinyur basis data, data
analis, dan manajer tingkat C.
xi
halaman 13
Tentang Peninjau Teknis

Sundar Rajan Raman memiliki lebih dari 14 tahun
pengalaman TI tumpukan penuh dalam mesin
pembelajaran, pembelajaran mendalam, dan bahasa alami
pengolahan. Dia memiliki enam tahun data besar
pengembangan dan pengalaman arsitek,
termasuk bekerja dengan Hadoop dan
ekosistemnya serta NoSQL lainnya
teknologi seperti MongoDB dan
Kasandra. Faktanya, dia telah menjadi teknisi
pengulas beberapa buku tentang topik ini.
Dia juga tertarik untuk menyusun strategi menggunakan prinsip Design Thinking
dan melatih dan membimbing orang.
xiii
halaman 14
BAB 1
Dasar-dasar TensorFlow
Bab ini membahas dasar-dasar TensorFlow, pembelajaran mendalam
kerangka. Pembelajaran mendalam melakukan pekerjaan luar biasa dalam pengenalan pola,
terutama dalam konteks gambar, suara, ucapan, bahasa, dan waktu-
data seri. Dengan bantuan pembelajaran mendalam, Anda dapat mengklasifikasikan, memprediksi,
cluster, dan mengekstrak fitur. Untungnya, pada November 2015, Google
merilis TensorFlow, yang telah digunakan di sebagian besar produk Google
seperti Google Penelusuran, deteksi spam, pengenalan ucapan, Google
Asisten, Google Now, dan Google Foto. Menjelaskan dasar
komponen TensorFlow adalah tujuan dari bab ini.
TensorFlow memiliki kemampuan unik untuk melakukan subgraf parsial
komputasi sehingga memungkinkan pelatihan terdistribusi dengan bantuan
mempartisi jaringan saraf. Dengan kata lain, TensorFlow memungkinkan model
paralelisme dan paralelisme data. TensorFlow menyediakan beberapa API.
API level terendah—TensorFlow Core—menyediakan Anda dengan lengkap
kontrol pemrograman.
Perhatikan poin penting berikut terkait TensorFlow:
• Grafiknya adalah deskripsi perhitungan.
• Grafiknya memiliki simpul yang merupakan operasi.
• Ini mengeksekusi perhitungan dalam konteks sesi tertentu.
• Grafik harus diluncurkan dalam satu sesi untuk setiap

komputasi.
© Navin Kumar Manaswi 2018 1

NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python ,
https://doi.org/10.1007/978-1-4842-3516-4_1
halaman 15
BAB 1 DASAR-DASAR TENSORFLOW
• Sesi menempatkan operasi grafik ke perangkat

seperti CPU dan GPU.
• Sesi menyediakan metode untuk mengeksekusi grafik

operasi.
Untuk pemasangan, silakan kunjungi https://www.tensorflow.org/install/ .

Saya akan membahas topik-topik berikut:
Tensor
Sebelum Anda masuk ke perpustakaan TensorFlow, mari membiasakan diri dengan
unit dasar data di TensorFlow. Sebuah tensor adalah objek matematika
dan generalisasi skalar, vektor, dan matriks. Tensor dapat berupa
direpresentasikan sebagai array multidimensi. Sebuah tensor peringkat nol (urutan) adalah
tidak lain hanyalah skalar. Vektor/array adalah tensor peringkat 1, sedangkan a
halaman 16
matriks adalah tensor peringkat 2. Singkatnya, tensor dapat dianggap sebagai

n - array dimensi.
Berikut adalah beberapa contoh tensor:
• 5: Ini adalah tensor peringkat 0; ini adalah skalar dengan bentuk [ ].
• [2.,5., 3.]: Ini adalah tensor peringkat 1; ini adalah vektor

dengan bentuk [3].
• [[1., 2., 7.], [3., 5., 4.]]: Ini adalah peringkat 2

tensor; itu adalah matriks dengan bentuk [2, 3].
• [[[1., 2., 3.]], [[7., 8., 9.]]]: Ini adalah peringkat 3

tensor dengan bentuk [2, 1, 3].
Grafik dan Sesi Komputasi

TensorFlow populer dengan program TensorFlow Core-nya yang memiliki dua
tindakan utama.
• Membangun grafik komputasi dalam konstruksi

fase
• Menjalankan grafik komputasi dalam eksekusi

fase
Mari kita pahami cara kerja TensorFlow.
• Program-programnya biasanya disusun menjadi sebuah konstruksi

fase dan fase eksekusi.
• Tahap konstruksi merakit grafik yang memiliki

node (ops/operasi) dan edge (tensor).
• Fase eksekusi menggunakan sesi untuk menjalankan operasi

(operasi) dalam grafik.
3
halaman 17
• Operasi paling sederhana adalah konstanta yang tidak mengambil

input tetapi meneruskan output ke operasi lain yang melakukan
komputasi.
• Contoh operasi adalah perkalian

(atau penambahan atau pengurangan yang menggunakan dua matriks sebagai
masukan dan melewatkan matriks sebagai keluaran).
• Pustaka TensorFlow memiliki grafik default yang

konstruktor ops menambahkan node.
Jadi, struktur program TensorFlow memiliki dua fase, yang ditunjukkan di sini:
Sebuah grafik komputasi adalah serangkaian operasi TensorFlow diatur

menjadi grafik node.
Mari kita lihat TensorFlow versus Numpy. Di Numpy, jika Anda berencana untuk
kalikan dua matriks, Anda membuat matriks dan mengalikannya. Tapi di
TensorFlow, Anda menyiapkan grafik (grafik default kecuali Anda membuat grafik lain
grafik). Selanjutnya, Anda perlu membuat variabel, placeholder, dan konstanta
nilai dan kemudian buat sesi dan inisialisasi variabel. Akhirnya, Anda memberi makan
data itu ke placeholder untuk menjalankan tindakan apa pun.
halaman 18
Untuk benar-benar mengevaluasi node, Anda harus menjalankan grafik komputasi

dalam satu sesi.
Sebuah sesi merangkum kontrol dan keadaan runtime TensorFlow.
Kode berikut membuat objek Sesi:
sess = tf.Session()
Ia kemudian memanggil metode run-nya untuk menjalankan cukup banyak komputasi

grafik untuk mengevaluasi node1 dan node2.
Grafik komputasi mendefinisikan komputasi. Itu tidak menghitung
apa pun atau tidak memiliki nilai apa pun. Ini dimaksudkan untuk mendefinisikan operasi
disebutkan dalam kode. Grafik default dibuat. Jadi, Anda tidak perlu
buat itu kecuali jika Anda ingin membuat grafik untuk berbagai tujuan.
Sebuah sesi memungkinkan Anda untuk menjalankan grafik atau bagian dari grafik. Ini mengalokasikan
sumber daya (pada satu atau lebih CPU atau GPU) untuk eksekusi. Ini memegang
nilai aktual dari hasil dan variabel antara.
Nilai variabel, yang dibuat di TensorFlow, hanya valid dalam
satu sesi. Jika Anda mencoba menanyakan nilai sesudahnya di sesi kedua,
TensorFlow akan memunculkan kesalahan karena variabel tidak diinisialisasi di sana.
Untuk menjalankan operasi apa pun, Anda perlu membuat sesi untuk grafik itu. NS
session juga akan mengalokasikan memori untuk menyimpan nilai variabel saat ini
halaman 19
Berikut adalah kode untuk menunjukkan:
Konstanta, Placeholder, dan Variabel

Program TensorFlow menggunakan struktur data tensor untuk mewakili semua data—
hanya tensor yang dilewatkan di antara operasi dalam grafik komputasi. Anda
dapat menganggap tensor TensorFlow sebagai larik atau daftar n -dimensi. Sebuah tensor
memiliki tipe statis, peringkat, dan bentuk. Di sini grafik menghasilkan konstanta
hasil. Variabel mempertahankan status di seluruh eksekusi grafik.
halaman 20
Umumnya, Anda harus berurusan dengan banyak gambar dalam pembelajaran mendalam, jadi Anda
harus menempatkan nilai piksel untuk setiap gambar dan terus mengulangi semua gambar.
Untuk melatih model, Anda harus dapat memodifikasi grafik untuk menyetel
beberapa objek seperti berat dan bias. Singkatnya, variabel memungkinkan Anda untuk
menambahkan parameter yang dapat dilatih ke grafik. Mereka dibangun dengan tipe dan
nilai awal.
Mari buat konstanta di TensorFlow dan cetak.
Berikut adalah penjelasan dari kode sebelumnya secara sederhana:
1. Impor modul tensorflow dan beri nama tf.
2. Buat nilai konstanta (x) dan tetapkan

nilai numerik 12.
3. Buat sesi untuk menghitung nilai.
4. Jalankan variabel x saja dan cetak arusnya

nilai.
Dua langkah pertama termasuk dalam fase konstruksi, dan dua yang terakhir
langkah-langkah termasuk dalam fase eksekusi. Saya akan membahas konstruksi dan
fase eksekusi TensorFlow sekarang.
Anda dapat menulis ulang kode sebelumnya dengan cara lain, seperti yang ditunjukkan di sini:
halaman 21
Sekarang Anda akan menjelajahi bagaimana Anda membuat variabel dan menginisialisasinya. Di sini adalah
kode yang melakukannya:
Berikut penjelasan dari kode sebelumnya:
2. Buat nilai konstanta yang disebut x dan berikan

nilai numerik 12.
3. Buat variabel bernama y dan definisikan sebagai

persamaan 12+11.
4. Inisialisasi variabel dengan tf.global_variables_

penginisialisasi().
6. Jalankan model yang dibuat pada langkah 4.
7. Jalankan variabel y saja dan cetak arusnya

nilai.
Berikut ini beberapa kode lagi untuk Anda teliti:
halaman 22
Placeholder
Sebuah placeholder adalah variabel yang dapat Anda makan sesuatu untuk di lain waktu. Dia
dimaksudkan untuk menerima input eksternal. Placeholder dapat memiliki satu atau beberapa
dimensi, dimaksudkan untuk menyimpan array n -dimensi.
Berikut penjelasan dari kode sebelumnya:
2. Buat placeholder bernama x, dengan menyebutkan

tipe mengambang.
3. Buat tensor yang disebut y yang merupakan operasi dari

mengalikan x dengan 10 dan menambahkan 500 ke dalamnya. Perhatikan bahwa
setiap nilai awal untuk x tidak terdefinisi.
5. Tentukan nilai x dalam feed_dict untuk menjalankan y.

6. Cetak nilainya.
Dalam contoh berikut, Anda membuat matriks 2×4 (array 2D) untuk
menyimpan beberapa nomor di dalamnya. Anda kemudian menggunakan operasi yang sama seperti sebelumnya untuk
melakukan elemen-bijaksana mengalikan dengan 10 dan menambahkan 1 untuk itu. Dimensi pertama
dari placeholder adalah None, yang berarti sejumlah baris diperbolehkan.
halaman 23
Anda juga dapat mempertimbangkan larik 2D sebagai pengganti larik 1D. Ini dia
kode:
Ini adalah matriks 2x4. Jadi, jika Anda mengganti None dengan 2, Anda dapat melihat
keluaran yang sama.
Tetapi jika Anda membuat placeholder dengan bentuk [3, 4] (perhatikan bahwa Anda akan memberi makan
matriks 2x4 di lain waktu), ada kesalahan, seperti yang ditunjukkan di sini:
10
halaman 24

################# Apa yang terjadi dalam model linier ##########
# Bobot dan Bias sebagai Variabel yang harus disetel
W = tf.Variable([2], dtype=tf.float32)
b = tf.Variable([3], dtype=tf.float32)
# Dataset pelatihan yang akan diberikan saat pelatihan sebagai Placeholder
x = tf.placeholder(tf.float32)
# Model Linier
y=W*x+b
Konstanta diinisialisasi saat Anda memanggil tf.constant, dan nilainya

tidak akan pernah bisa berubah. Sebaliknya, variabel tidak diinisialisasi saat Anda memanggil
tf.Variabel. Untuk menginisialisasi semua variabel dalam program TensorFlow, Anda
harus secara eksplisit memanggil operasi khusus sebagai berikut.
Penting untuk disadari bahwa init adalah pegangan untuk subgraf TensorFlow
yang menginisialisasi semua variabel global. Sampai Anda memanggil sess.run, itu
variabel tidak diinisialisasi.
11
halaman 25
Membuat Tensor
Sebuah gambar adalah tensor dari urutan ketiga di mana dimensi milik
tinggi, lebar, dan jumlah saluran (Merah, Biru, dan Hijau).
Di sini Anda dapat melihat bagaimana gambar diubah menjadi tensor:
12
halaman 26
Anda dapat menghasilkan tensor dari berbagai jenis seperti tensor tetap,
tensor acak, dan tensor berurutan.
Tensor Tetap
Berikut adalah tensor tetap:
13
halaman 27
tf:.fill membuat tensor bentuk (2×3) yang memiliki nomor unik.
tf.diag membuat matriks diagonal yang memiliki elemen diagonal tertentu.
tf.constant membuat tensor konstan.
Urutan Tensor
tf.range membuat urutan angka mulai dari nilai yang ditentukan
dan memiliki kenaikan tertentu.
tf.linspace membuat urutan nilai dengan jarak yang sama.
14
halaman 28
Tensor Acak
tf.random_uniform menghasilkan nilai acak dari distribusi seragam
dalam suatu jangkauan.
tf.random_normal menghasilkan nilai acak dari normal

distribusi yang memiliki mean dan standar deviasi yang ditentukan.
15
halaman 29
Bisakah Anda menebak hasilnya?
Jika Anda tidak dapat menemukan hasilnya, harap perbaiki bagian sebelumnya
dimana saya membahas pembuatan tensor.
Di sini Anda dapat melihat hasilnya:
Bekerja di Matriks
Setelah Anda merasa nyaman membuat tensor, Anda dapat menikmati mengerjakannya
matriks (tensor 2D).
16
halaman 30
Fungsi Aktivasi
Ide fungsi aktivasi berasal dari analisis bagaimana a
neuron bekerja di otak manusia (lihat Gambar 1-1 ). Neuron menjadi
aktif melampaui ambang batas tertentu, lebih dikenal sebagai potensial aktivasi .
Itu juga mencoba untuk menempatkan output ke dalam kisaran kecil dalam banyak kasus.
Sigmoid, tangen hiperbolik (tanh), ReLU, dan ELU adalah yang paling populer
fungsi aktivasi.
Mari kita lihat fungsi aktivasi yang populer.
17
halaman 31
Tangen Hiperbolik dan Sigmoid

Angka 1-2 menunjukkan fungsi aktivasi hiperbolik dan sigmoid tangen.
Gambar 1-1. Fungsi aktivasi
Gambar 1-2. Dua fungsi aktivasi populer
18
halaman 32
Berikut adalah kode demonya:
ReLU dan ELU

Angka 1-3 menunjukkan fungsi ReLU dan ELU.
Gambar 1-3. Fungsi ReLU dan ELU

19
halaman 33
Berikut adalah kode untuk menghasilkan fungsi-fungsi ini:
ReLU6
ReLU6 mirip dengan ReLU kecuali outputnya tidak boleh lebih dari enam.
Perhatikan bahwa tanh adalah fungsi sigmoid logistik yang diskalakan.
20
halaman 34

21
halaman 35
Fungsi Rugi
Fungsi kerugian (fungsi biaya) harus diminimalkan untuk mendapatkan yang terbaik
nilai untuk setiap parameter model. Misalnya, Anda perlu mendapatkan
nilai terbaik dari bobot (slope) dan bias (y-intercept) sehingga dapat menjelaskan
target (y) dalam hal prediktor (X). Caranya adalah untuk mencapai yang terbaik
nilai kemiringan, dan perpotongan y adalah untuk meminimalkan fungsi biaya/kerugian
fungsi/jumlah kuadrat. Untuk model apapun, ada banyak parameter,
dan struktur model dalam prediksi atau klasifikasi dinyatakan dalam
istilah dari nilai parameter.
Anda perlu mengevaluasi model Anda, dan untuk itu Anda perlu mendefinisikan
fungsi biaya (fungsi kerugian). Minimalisasi fungsi kerugian dapat
menjadi kekuatan pendorong untuk menemukan nilai optimal dari setiap parameter. Untuk
22
halaman 36
regresi/prediksi numerik, L1 atau L2 dapat menjadi fungsi kerugian yang berguna.

Untuk klasifikasi, entropi silang dapat menjadi fungsi kerugian yang berguna. Softmax atau
entropi silang sigmoid bisa menjadi fungsi kerugian yang cukup populer.
Contoh Fungsi Rugi

Fungsi Rugi Umum

Berikut ini adalah daftar fungsi kerugian yang paling umum:
tf.contrib.losses.absolute_difference
tf.contrib.losses.add_loss
23
halaman 37
tf.contrib.losses.hinge_loss
tf.contrib.losses.compute_weighted_loss
tf.contrib.losses.cosine_distance
tf.contrib.losses.get_losses
tf.contrib.losses.get_regularization_losses
tf.contrib.losses.get_total_loss
tf.contrib.losses.log_loss
tf.contrib.losses.mean_pairwise_squared_error
tf.contrib.losses.mean_squared_error
tf.contrib.losses.sigmoid_cross_entropy
tf.contrib.losses.softmax_cross_entropy
tf.contrib.losses.sparse_softmax_cross_entropy
tf.contrib.losses.log(prediksi,label,berat=2.0)
24
halaman 38
Pengoptimal
Sekarang Anda harus yakin bahwa Anda perlu menggunakan fungsi kerugian untuk
mendapatkan nilai terbaik dari setiap parameter model. Bagaimana Anda bisa mendapatkan
nilai terbaik?
Awalnya Anda mengasumsikan nilai awal bobot dan bias untuk model
(regresi linier, dll.). Sekarang Anda perlu menemukan cara untuk mencapai
nilai parameter terbaik. Pengoptimal adalah cara untuk mencapai yang terbaik
nilai parameter. Dalam setiap iterasi, nilai berubah dalam arah
disarankan oleh pengoptimal. Misalkan Anda memiliki 16 nilai bobot (w1, w2,
w3, …, w16) dan 4 bias (b1, b2, b3, b4). Awalnya Anda dapat mengasumsikan setiap
bobot dan bias menjadi nol (atau satu atau angka apa pun). Pengoptimal menyarankan
apakah w1 (dan parameter lainnya) harus meningkat atau menurun dalam
iterasi berikutnya sambil menjaga tujuan minimalisasi dalam pikiran. Setelah banyak
iterasi, w1 (dan parameter lainnya) akan stabil ke nilai terbaik
(atau nilai) parameter.
Dengan kata lain, TensorFlow, dan setiap kerangka kerja pembelajaran mendalam lainnya,
menyediakan pengoptimal yang perlahan mengubah setiap parameter untuk
meminimalkan fungsi kerugian. Tujuan dari pengoptimal adalah untuk memberikan
arah ke bobot dan bias untuk perubahan pada iterasi berikutnya.
Asumsikan bahwa Anda memiliki 64 bobot dan 16 bias; Anda mencoba untuk mengubah
bobot dan nilai bias pada setiap iterasi (selama backpropagation) sehingga
Anda mendapatkan nilai bobot dan bias yang benar setelah banyak iterasi saat
mencoba meminimalkan fungsi kerugian.
Memilih pengoptimal terbaik agar model dapat menyatu dengan cepat dan dipelajari
bobot dan bias dengan benar adalah tugas yang rumit.
Teknik adaptif (adadelta, adagrad, dll.) adalah pengoptimal yang baik
untuk konvergen lebih cepat untuk jaringan saraf yang kompleks. Adam seharusnya
pengoptimal terbaik untuk sebagian besar kasus. Ini juga mengungguli adaptif lainnya
teknik (adadelta, adagrad, dll.), tetapi secara komputasi mahal. Untuk
kumpulan data yang jarang, metode seperti SGD, NAG, dan momentum bukanlah
pilihan terbaik; yang tingkat pembelajaran adaptif metode yang. Manfaat tambahan
25
halaman 39
adalah bahwa Anda tidak perlu menyesuaikan kecepatan belajar tetapi kemungkinan besar dapat mencapai
hasil terbaik dengan nilai default.
Contoh Fungsi Rugi

26
halaman 40

Pengoptimal Umum
Berikut adalah daftar pengoptimal umum:
27
halaman 41
Metrik
Setelah mempelajari beberapa cara untuk membangun model, sekarang saatnya untuk mengevaluasi
model. Jadi, Anda perlu mengevaluasi regressor atau classifier.
Ada banyak metrik evaluasi, di antaranya klasifikasi
akurasi, kerugian logaritmik, dan area di bawah kurva ROC adalah yang paling populer
yang.
Akurasi klasifikasi adalah rasio jumlah prediksi yang benar
ke jumlah semua prediksi. Ketika pengamatan untuk setiap kelas tidak
banyak miring, akurasi dapat dianggap sebagai metrik yang baik.
tf.contrib.metrics.accuracy(label_aktual, prediksi)
Ada metrik evaluasi lainnya juga.
Contoh Metrik
Bagian ini menunjukkan kode untuk didemonstrasikan.
Di sini Anda membuat nilai aktual (menyebutnya x) dan nilai prediksi
(memanggil mereka y). Kemudian Anda memeriksa keakuratannya. Akurasi mewakili
rasio berapa kali aktual sama dengan nilai prediksi dan
jumlah total instance.
28
halaman 42
Metrik Umum
Berikut adalah daftar metrik umum:
29
halaman 43
30
halaman 44
BAB 2
Memahami dan
Bekerja di Keras
Keras adalah library Python tingkat tinggi yang ringkas dan mudah dipelajari untuk deep
pembelajaran yang dapat berjalan di atas TensorFlow (atau Theano atau CNTK). Dia
memungkinkan pengembang untuk fokus pada konsep utama pembelajaran mendalam, seperti
sebagai membuat lapisan untuk jaringan saraf, sambil mengurus seluk beluknya
detail tensor, bentuknya, dan detail matematisnya. TensorFlow
(atau Theano atau CNTK) harus menjadi back end untuk Keras. Anda dapat menggunakan Keras
untuk aplikasi pembelajaran mendalam tanpa berinteraksi dengan relatif
kompleks TensorFlow (atau Theano atau CNTK). Ada dua jenis utama
kerangka kerja: API sekuensial dan API fungsional. berurutan
API didasarkan pada gagasan tentang urutan lapisan; ini yang paling umum
penggunaan Keras dan bagian termudah dari Keras. Model sekuensial dapat
dianggap sebagai tumpukan linier lapisan.
Singkatnya, Anda membuat model sekuensial di mana Anda dapat dengan mudah menambahkan
lapisan, dan setiap lapisan dapat memiliki konvolusi, max pooling, aktivasi, drop-
keluar, dan normalisasi batch. Mari kita melalui langkah-langkah utama untuk berkembang
model pembelajaran mendalam di Keras.

https://doi.org/10.1007/978-1-4842-3516-4_2
halaman 45
BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
Langkah-Langkah Utama untuk Model Pembelajaran Mendalam

Empat bagian inti model deep learning di Keras adalah sebagai berikut:
1. Tentukan modelnya. Di sini Anda membuat sekuensial

model dan tambahkan lapisan. Setiap lapisan dapat berisi satu
atau lebih konvolusi, penyatuan, normalisasi batch,
dan fungsi aktivasi.
2. Kompilasi modelnya. Di sini Anda menerapkan kerugian

fungsi dan pengoptimal sebelum memanggil compile()
fungsi pada model.
3. Sesuaikan model dengan data pelatihan. Di sini Anda melatih

model pada data uji dengan memanggil fungsi fit()
pada modelnya.
4. Buat prediksi. Di sini Anda menggunakan model untuk

menghasilkan prediksi pada data baru dengan menelepon
fungsi seperti evaluasi() dan prediksi().
Ada delapan langkah proses deep learning di Keras:
1. Muat datanya.
2. Praproses data.
3. Tentukan modelnya.
4. Kompilasi modelnya.
5. Sesuaikan modelnya.
6. Evaluasi modelnya.
7. Buat prediksi.
8. Simpan modelnya.
32
halaman 46
Muat Data
Berikut adalah cara Anda memuat data:
Praproses Data
Berikut adalah cara Anda memproses data sebelumnya:
33
halaman 47
Tentukan Modelnya
Model sekuensial di Keras didefinisikan sebagai urutan lapisan. Anda
membuat model sekuensial dan kemudian menambahkan lapisan. Anda perlu memastikan
lapisan input memiliki jumlah input yang tepat. Asumsikan Anda memiliki 3.072
variabel masukan; maka Anda perlu membuat lapisan tersembunyi pertama dengan 512
node/neuron. Di lapisan tersembunyi kedua, Anda memiliki 120 node/neuron.
Akhirnya, Anda memiliki sepuluh node di lapisan output. Misalnya, gambar
memetakan ke sepuluh node yang menunjukkan kemungkinan menjadi label1 (pesawat),
label2 (mobil), label3 (kucing), …, label10 (truk). Node tertinggi
probabilitas adalah kelas/label yang diprediksi.
Satu gambar memiliki tiga saluran (RGB), dan di setiap saluran,

gambar memiliki 32 × 32 = 1024 piksel. Jadi, setiap gambar memiliki 3 × 1024 = 3072 piksel
(fitur/X/input).
Dengan bantuan 3.072 fitur, Anda perlu memprediksi kemungkinan
label1 (Digit 0), label2 (Digit 1), dan seterusnya. Ini berarti model memprediksi
sepuluh output (Digit 0-9) di mana setiap output mewakili probabilitas
label yang sesuai. Fungsi aktivasi terakhir (sigmoid, seperti yang ditunjukkan
sebelumnya) memberikan 0 untuk sembilan output dan 1 hanya untuk satu output. Label itu adalah
prediksi kelas untuk gambar (Gambar 2-1).
Misalnya, 3.072 fitur 512 node 120 node 10 node.
34
halaman 48
Gambar 2-1. Mendefinisikan model
Pertanyaan selanjutnya adalah, bagaimana Anda mengetahui jumlah lapisan yang akan digunakan dan
tipe mereka? Tidak ada yang punya jawaban pasti. Yang terbaik untuk metrik evaluasi adalah
bahwa Anda memutuskan jumlah lapisan yang optimal dan parameter serta langkah-langkahnya
di setiap lapisan. Pendekatan heuristik juga digunakan. Struktur jaringan terbaik
ditemukan melalui proses eksperimentasi coba-coba. Umumnya, Anda
membutuhkan jaringan yang cukup besar untuk menangkap struktur masalah.
35
halaman 49
Dalam contoh ini, Anda akan menggunakan struktur jaringan yang sepenuhnya terhubung dengan
tiga lapisan. Kelas padat mendefinisikan lapisan yang terhubung penuh.
Dalam hal ini, Anda menginisialisasi bobot jaringan ke acak kecil
bilangan yang dihasilkan dari distribusi seragam (uniform) dalam hal ini
kasus antara 0 dan 0,05 karena itu adalah bobot seragam default
inisialisasi di Keras. Alternatif tradisional lainnya akan normal untuk
bilangan acak kecil yang dihasilkan dari distribusi Gaussian. Anda menggunakan atau
snap ke klasifikasi keras dari kedua kelas dengan ambang default 0,5.
Anda dapat menggabungkan semuanya dengan menambahkan setiap lapisan.
Kompilasi Modelnya
Setelah mendefinisikan model dalam hal lapisan, Anda perlu mendeklarasikan kerugian
fungsi, pengoptimal, dan metrik evaluasi. Ketika modelnya
diusulkan, bobot awal dan nilai bias diasumsikan 0 atau 1, a
nomor terdistribusi normal acak, atau nomor nyaman lainnya.
Tetapi nilai awal bukanlah nilai terbaik untuk model. Ini berarti
nilai awal bobot dan bias tidak mampu menjelaskan target/label dalam
istilah prediktor (Xs). Jadi, Anda ingin mendapatkan nilai optimal untuk model tersebut.
Perjalanan dari nilai awal menuju nilai optimal membutuhkan motivasi, yang
akan meminimalkan fungsi biaya/fungsi kerugian. Perjalanan butuh jalan
(perubahan di setiap iterasi), yang disarankan oleh pengoptimal. Perjalanan
juga membutuhkan pengukuran evaluasi, atau metrik evaluasi.
Fungsi kerugian yang populer adalah entropi silang biner, persilangan kategoris
entropi, mean_squared_logarithmic_error dan kehilangan engsel. Populer
pengoptimal adalah penurunan gradien stokastik (SGD), RMSProp, adam,
adagrad, dan adadelta. Metrik evaluasi yang populer adalah akurasi, ingatan,
dan skor F1.
36
halaman 50
Singkatnya, langkah ini ditujukan untuk menyetel bobot dan bias berdasarkan
kehilangan fungsi melalui iterasi berdasarkan pengoptimal yang dievaluasi oleh
metrik seperti akurasi.
Sesuaikan Modelnya
Setelah mendefinisikan dan menyusun model, Anda perlu membuat prediksi
dengan mengeksekusi model pada beberapa data. Di sini Anda perlu menentukan
zaman; ini adalah jumlah iterasi untuk menjalankan proses pelatihan
melalui kumpulan data dan ukuran batch, yang merupakan jumlah instance
yang dievaluasi sebelum pembaruan bobot. Untuk masalah ini, program
akan berjalan untuk sejumlah kecil zaman (10), dan di setiap zaman, itu akan
menyelesaikan 50 (= 50.000/1.000) iterasi di mana ukuran batch adalah 1.000 dan
set data pelatihan memiliki 50.000 instans/gambar. Sekali lagi, tidak ada aturan keras
untuk memilih ukuran batch. Tapi seharusnya tidak terlalu kecil, dan seharusnya
jauh lebih kecil dari ukuran set data pelatihan untuk mengkonsumsi lebih sedikit memori.
37
halaman 51
Evaluasi Model
Setelah melatih jaringan saraf pada set data pelatihan, Anda perlu
untuk mengevaluasi kinerja jaringan. Perhatikan bahwa ini hanya akan memberi
Anda memiliki gambaran seberapa baik Anda telah memodelkan kumpulan data (misalnya, kereta api
akurasi), tetapi Anda tidak akan tahu seberapa baik kinerja algoritme
pada data baru. Ini untuk kesederhanaan, tetapi idealnya, Anda dapat memisahkan
data ke dalam set data latih dan uji untuk pelatihan dan evaluasi Anda
model. Anda dapat mengevaluasi model Anda pada kumpulan data pelatihan Anda menggunakan
evaluasi() pada model Anda dan berikan input yang sama dan
output yang digunakan untuk melatih model. Ini akan menghasilkan prediksi untuk masing-masing
pasangan input dan output dan mengumpulkan skor, termasuk kerugian rata-rata dan
metrik apa pun yang telah Anda konfigurasikan, seperti akurasi.
Ramalan
Setelah Anda membangun dan mengevaluasi model, Anda perlu memprediksi untuk
data yang tidak diketahui.
38
halaman 52
Simpan dan Muat Ulang Model

Berikut adalah langkah terakhir:
Opsional: Ringkas Modelnya

Sekarang mari kita lihat bagaimana meringkas model.
39
halaman 53
Langkah Tambahan untuk Meningkatkan Model Keras

Berikut adalah beberapa langkah lagi untuk meningkatkan model Anda:
1. Terkadang, proses pembuatan model tidak
lengkap karena menghilang atau meledak
gradien. Jika ini masalahnya, Anda harus melakukan
mengikuti:
2. Modelkan bentuk keluaran.
#Bentuk array n-redup (output dari model

pada posisi saat ini)
model.output_shape
3. Model representasi ringkasan.
model.ringkasan()
4. Modelkan konfigurasi.
model.get_config()
5. Buat daftar semua tensor bobot dalam model.
model.get_weights()
Berikut saya bagikan kode lengkap untuk model Keras. Bisakah kamu
mencoba menjelaskannya?
40
halaman 54

41
halaman 55
Keras dengan TensorFlow

Keras menyediakan jaringan saraf tingkat tinggi dengan memanfaatkan yang kuat dan
perpustakaan pembelajaran mendalam yang jernih di atas TensorFlow/Theano. Keras itu hebat
selain TensorFlow karena lapisan dan modelnya kompatibel dengan pure-
TensorFlow tensor. Selain itu, dapat digunakan bersama TensorFlow lainnya
perpustakaan.
Berikut adalah langkah-langkah yang terlibat dalam menggunakan Keras untuk TensorFlow:
1. Mulailah dengan membuat sesi TensorFlow dan

mendaftarkannya ke Keras. Ini berarti Keras akan
gunakan sesi yang Anda daftarkan untuk menginisialisasi semua
variabel yang diciptakannya secara internal.
impor TensorFlow sebagai tf

sess = tf.Session()
dari hard import backend sebagai K
K.set_session(sess)
2. Modul Keras seperti model, layer, dan

aktivasi digunakan untuk membangun model. Keras
engine secara otomatis mengubah modul ini menjadi
skrip yang setara dengan TensorFlow.
3. Selain TensorFlow, Theano dan CNTK dapat menjadi

digunakan sebagai ujung belakang ke Keras.
4. Bagian belakang TensorFlow memiliki konvensi

membuat bentuk input (ke lapisan pertama Anda
jaringan) dalam kedalaman, tinggi, urutan lebar, di mana kedalaman
dapat berarti jumlah saluran.
42
halaman 56

5. Anda perlu mengkonfigurasi file keras.json dengan benar
sehingga menggunakan back end TensorFlow. Itu seharusnya
terlihat seperti ini:
"backend": "theano",
"epsilon": 1e-07,
"image_data_format": "channels_first",
"floatx": "float32"
Di bab-bab berikutnya, Anda akan belajar bagaimana memanfaatkan Keras untuk bekerja
CNN, RNN, LSTM, dan aktivitas pembelajaran mendalam lainnya.
43
halaman 57
BAGIAN 3
Perceptron berlapis-lapis
Sebelum Anda mulai belajar tentang perceptron berlapis-lapis, Anda perlu mendapatkan
tampilan gambaran besar dari jaringan saraf tiruan. Itulah yang akan saya mulai dengan
Bab ini.
Jaringan Saraf Buatan

Sebuah jaringan saraf tiruan (JST) adalah jaringan komputasi (sistem
node dan interkoneksi antara node) terinspirasi oleh biologis
jaringan saraf, yang merupakan jaringan kompleks neuron pada manusia
otak (lihat Gambar 3-1). Node yang dibuat di ANN seharusnya
diprogram untuk berperilaku seperti neuron yang sebenarnya, dan karenanya mereka buatan
neuron. Gambar 3-1 menunjukkan jaringan node (neuron buatan)
yang membentuk jaringan saraf tiruan.
© Navin Kumar Manaswi 2018

45
https://doi.org/10.1007/978-1-4842-3516-4_3
halaman 58
BAB 3 PERCEPTRON MULTILAYER
Gambar 3-1. Jaringan saraf tiruan
Jumlah lapisan dan jumlah neuron/simpul per lapisan dapat

menjadi komponen struktural utama dari jaringan saraf tiruan. Mulanya,
bobot (mewakili interkoneksi) dan bias tidak baik
cukup untuk membuat keputusan (klasifikasi, dll). Ini seperti otak
bayi yang tidak memiliki pengalaman sebelumnya. Seorang bayi belajar dari pengalaman sehingga
menjadi pembuat keputusan (classifier) yang baik. Pengalaman/data (berlabel) membantu
jaringan saraf otak menyetel bobot dan bias (saraf). buatan
jaringan saraf melalui proses yang sama. Bobotnya disetel per
iterasi untuk membuat classifier yang baik. Sejak menyetel dan dengan demikian mendapatkan
bobot yang benar dengan tangan untuk ribuan neuron sangat memakan waktu,
Anda menggunakan algoritma untuk melakukan tugas ini.
Proses penyetelan bobot itu disebut pembelajaran atau pelatihan . Ini adalah
sama seperti yang dilakukan manusia sehari-hari. Kami mencoba mengaktifkan komputer
untuk tampil seperti manusia.
Mari kita mulai menjelajahi model JST yang paling sederhana.
Jaringan saraf tipikal mengandung sejumlah besar neuron buatan
disebut unit yang disusun dalam serangkaian lapisan yang berbeda: lapisan input, tersembunyi
lapisan, dan lapisan keluaran (Gambar 3-2 ).
46
halaman 59
Gambar 3-2. Jaringan syaraf
Jaringan saraf terhubung, yang berarti setiap neuron di

lapisan tersembunyi sepenuhnya terhubung ke setiap neuron di input sebelumnya
lapisan dan ke lapisan keluaran berikutnya. Jaringan saraf belajar dengan menyesuaikan
bobot dan bias pada setiap layer secara iteratif untuk mendapatkan hasil yang optimal.
Perceptron Lapisan Tunggal

Perceptron single-layer adalah pengklasifikasi biner linier sederhana. Dibutuhkan masukan
dan bobot terkait dan menggabungkannya untuk menghasilkan output yang digunakan
untuk klasifikasi. Tidak memiliki lapisan tersembunyi. Regresi logistik adalah satu-
lapisan perceptron.
Sebuah perceptron multilayer (MLP) adalah contoh sederhana dari umpan balik buatan
jaringan saraf. Sebuah MLP terdiri dari setidaknya satu lapisan tersembunyi dari node
selain lapisan input dan lapisan output. Setiap node dari lapisan lainnya
47
halaman 60
daripada lapisan input disebut neuron yang menggunakan aktivasi nonlinier

fungsi seperti sigmoid atau ReLU. MLP menggunakan pembelajaran yang diawasi
teknik yang disebut backpropagation untuk pelatihan, sambil meminimalkan kerugian
fungsi seperti entropi silang. Ini menggunakan pengoptimal untuk menyetel parameter
(bobot dan bias). Beberapa lapisan dan aktivasi nonliniernya membedakan
sebuah MLP dari perceptron linier.
Perceptron multilayer adalah bentuk dasar dari jaringan saraf yang dalam.
Sebelum Anda belajar tentang MLP, mari kita lihat model linier dan logistik
model. Anda dapat menghargai perbedaan halus antara linier, logistik,
dan model MLP dalam hal kompleksitas.
Angka 3-3 menunjukkan model linier dengan satu masukan (X) dan satu keluaran (Y).
Gambar 3-3. Vektor masukan tunggal
Model input tunggal memiliki vektor X dengan bobot W dan bias b. NS

output, Y, adalah WX + b, yang merupakan model linier.
Angka 3-4 menunjukkan beberapa input (X1 dan X2) dan satu output (Y).
Gambar 3-4. model linier
48
halaman 61
Model linier ini memiliki dua fitur input: X1 dan X2 dengan

bobot yang sesuai untuk setiap fitur input menjadi W1, W2, dan bias b. NS
keluaran, Y, adalah W1X1 + W2X2 + b.
Model Regresi Logistik

Angka 3-5 menunjukkan algoritma pembelajaran yang Anda gunakan saat label keluaran
Y adalah 0 atau 1 untuk masalah klasifikasi biner. Diberikan fitur masukan
vektor X, Anda menginginkan probabilitas bahwa Y = 1 diberikan fitur input X. Ini
disebut juga sebagai jaringan syaraf dangkal atau lapisan tunggal (tidak ada lapisan tersembunyi;
saja dan lapisan keluaran) jaringan saraf. Lapisan keluaran, Y, adalah (Z), di mana Z
adalah WX + b dan adalah fungsi sigmoid.
Gambar 3-5. Satu masukan (X) dan satu keluaran (Y)
Angka 3-6 menunjukkan algoritma pembelajaran yang Anda gunakan saat output
label Y adalah 0 atau 1 untuk masalah klasifikasi biner.
Gambar 3-6. Beberapa input (X1 dan X1) dan satu output (Y)
49
halaman 62
Diberikan vektor fitur input X1 dan X2, Anda menginginkan probabilitas bahwa
Y = 1 diberikan fitur input. Ini juga disebut perceptron . Hasil
lapisan, Y, adalah (Z), di mana Z adalah WX + b.
é x 1ù éW 1 W 2 ù é x 1 ù é B1 ù æé W 1 * x 1 + W 2 * x 2 1+ B ù Hai
ê ® ê úê + ê ® S Cê ú÷
ëx 2û ëW 3 W 4 û ë x 2 û ë B2 û è ëW 3 * x 1 + W 4 * x 2 + B 2 û Hai
Angka 3-7 menunjukkan jaringan saraf dua lapis, dengan lapisan tersembunyi dan
sebuah lapisan keluaran. Pertimbangkan bahwa Anda memiliki dua vektor fitur input X1 dan X2
menghubungkan ke dua neuron, X1' dan X2'. Parameter (bobot) yang terkait
dari lapisan input ke lapisan tersembunyi adalah w1, w2, w3, w4, b1, b2.
Gambar 3-7. Jaringan saraf dua lapis
50
halaman 63
X1' dan X2' menghitung kombinasi linier (Gambar 3-8 ).
é x 1' ù éw 1 w 2ùé x 1ù é B1 ù
ê = ê úê + ê ú
ë x 2' û ëw 3 w 4ûëx 2û ëB 2 û
(2×1)(2×2)(2×1)(2×1) adalah dimensi dari lapisan masukan dan lapisan tersembunyi.

Gambar 3-8. Komputasi dalam jaringan saraf
Input linier X1' dan X2' melewati unit aktivasi a1 dan

a2 di lapisan tersembunyi.
a1 adalah (X1') dan a2 adalah (X2'), sehingga Anda juga dapat menulis persamaan sebagai berikut:
é A1 ù é x 1' ù
ê = S ê ú
ë A2 û ëx 2 'û
51
halaman 64
Nilai maju menyebar dari lapisan tersembunyi ke output

lapisan. Input a1 dan a2 dan parameter w5, w6, dan b3 melewati
lapisan keluaran a' (Gambar 3-9 ).
Gambar 3-9. Propagasi maju
é A1 ù
a'= [ w 5 w 6 ]ê B 3 membuat kombinasi linier dari (w5*a1 +
û[]
ëA 2 +
w6*a2) + b3, yang akan melewati fungsi sigmoid nonlinier ke
lapisan keluaran akhir, Y.
s a'
y=( )
Misalkan struktur model awal dalam satu dimensi adalah Y = w*X + b,

dimana parameter w dan b adalah bobot dan bias.
52
halaman 65
Pertimbangkan fungsi kerugian L(w, b) = 0,9 untuk nilai awal

parameter w = 1 dan b = 1. Anda mendapatkan output ini: y = 1*X+1 & L(w ,b) = 0.9.
Tujuannya adalah untuk meminimalkan kerugian dengan menyesuaikan parameter w
dan B. Kesalahan akan dipropagasi mundur dari lapisan keluaran ke
lapisan tersembunyi ke lapisan input untuk menyesuaikan parameter melalui pembelajaran
tingkat dan pengoptimal. Akhirnya, kami ingin membangun model (regressor) yang dapat
jelaskan Y dalam hal X.
Untuk memulai proses membangun model, kami menginisialisasi bobot dan bias. Untuk
kenyamanan, w = 1, b = 1 (Nilai awal), (pengoptimal) gradien stokastik
keturunan dengan learning rate (α = 0,01).
Berikut adalah langkah 1: Y = 1 * X + 1.
1,20 0,35
Parameter disesuaikan dengan w = 1,20 dan b = 0,35.
Inilah langkah 2: Y1 = 1,20*X + 0,35.
1,24 0,31
Parameter disesuaikan dengan w = 1,24 dan b = 0,31.
Berikut langkah 3: Y1 = 1,24*X + 0,31.
1,25 0,30
53
halaman 66
Setelah beberapa iterasi, bobot dan bias menjadi stabil. Seperti yang kamu lihat,
perubahan awal tinggi saat menyetel. Setelah beberapa iterasi, perubahan
tidak signifikan.
L(w, b) diminimalkan untuk w = 1,26 dan b = 0,29; oleh karena itu, model akhir
menjadi sebagai berikut:
Y = 1,26 * X + 0,29
Demikian pula, dalam dua dimensi, Anda dapat mempertimbangkan parameter, bobot
matriks dan vektor bias.
é1 1 ù
Mari kita asumsikan bahwa matriks bobot awal dan vektor bias sebagai W = ê ú
ë1 1 û
é1 ù
dan B = ê ú .
ë1 û
Anda mengulangi dan menyebarkan kembali kesalahan untuk menyesuaikan w dan b.
é1 1 ù é1 ù
=
YW =ê
* [ ]x+ ê ú adalah model awal. Matriks bobot (2x2)
ë1 1 û ë1 û
dan matriks bias (2x1) disetel di setiap iterasi. Jadi, kita bisa melihat perubahan dalam
matriks bobot dan bias
Inilah langkah 1:
é07. 08 . ù é 2 .4 ù
W =ê ú, =
B ê ú
ë06. 12 . û ë 3 .2 û
54
halaman 67
Inilah langkah 2:
é 07. 08 . ù é2 .4 ù
ê ú ê ú
ë 06. 12 . û ë3 .2 û
é 06. 07 . ù é 2 .8 ù
W =ê ú, B
= ê ú
ë 04. 13 . û ë 3 .8 û
Inilah langkah 3:
é 06. 07 . ù é 2 .8 ù
ê ú ê ú
ë 04. 13 . û ë 3 .8 û
Anda dapat melihat perubahan dalam matriks bobot (2x2) dan matriks bias (2x1) di
iterasi.
é 05. 06 . ù é 2 .9 ù
W =ê ú, =
B ê ú
ë 03. 13 . û ë 4 .0 û
55
halaman 68
Model akhir setelah w dan b disesuaikan adalah sebagai berikut:
é 04. 05 . ù é 3 .0 ù
Y= ê * [ ]x+ ê ú
ë 02. 13 . û ë 4 .0 û
Dalam bab ini, Anda mempelajari bagaimana bobot dan bias disetel di masing-masing
iterasi sambil menjaga tujuan meminimalkan fungsi kerugian. Itu adalah
dilakukan dengan bantuan pengoptimal seperti penurunan gradien stokastik.
Dalam bab ini, kita telah memahami ANN dan MLP sebagai dasar yang dalam
model pembelajaran. Di sini, kita dapat melihat MLP sebagai perkembangan alami dari
regresi linier dan logistik. Kami telah melihat betapa berat dan biasnya
disetel di setiap iterasi yang terjadi di backpropagation. Tanpa
masuk ke rincian backpropagation, kita telah melihat aksi/hasil dari
propagasi balik. Dalam dua bab berikutnya, kita dapat mempelajari cara membangun MLP
model di TensorFlow dan dalam keras.
56
halaman 69
BAB 4
Regresi ke MLP
di TensorFlow
Orang-orang telah menggunakan regresi dan pengklasifikasi untuk waktu yang lama. Sekarang saatnya
untuk beralih ke topik jaringan saraf. Perceptron berlapis - lapis (MLP)
adalah model jaringan saraf sederhana di mana Anda dapat menambahkan satu atau lebih tersembunyi
lapisan antara lapisan input dan output.
Dalam bab ini, Anda akan melihat bagaimana TensorFlow dapat membantu Anda membangun
model. Anda akan mulai dengan model paling dasar, yaitu model linier.
Model logistik dan MLP juga dibahas dalam bab ini.
Langkah-Langkah TensorFlow untuk Membangun Model

Di bagian ini, saya akan membahas langkah-langkah membangun model di TensorFlow. saya akan
memandu Anda melalui langkah-langkah di sini, dan kemudian Anda akan melihat kode di seluruh
Bab ini:
1. Muat datanya.
2. Pisahkan data ke dalam kereta dan uji.
3. Normalisasi jika diperlukan.
4. Inisialisasi placeholder yang akan berisi prediktor

dan targetnya.

57
https://doi.org/10.1007/978-1-4842-3516-4_4
halaman 70
BAB 4 REGRESI MLP DI TENSORFLOW
5. Buat variabel (bobot dan bias) yang akan disetel.
6. Mendeklarasikan operasi model.
7. Deklarasikan fungsi kerugian dan pengoptimal.
8. Inisialisasi variabel dan sesi.
9. Sesuaikan model dengan menggunakan loop pelatihan.
10. Periksa dan tampilkan hasilnya dengan data uji.
Regresi Linier di TensorFlow

Pertama, Anda perlu memahami kode untuk regresi linier di TensorFlow.
Angka 4-1 menunjukkan model linier dasar.
Seperti yang ditunjukkan pada Gambar 4-1 , bobot (W) dan bias (b) harus disetel sehingga
untuk mendapatkan nilai bobot dan bias yang tepat. Jadi, bobot (W) dan bias (b)
adalah variabel dalam kode TensorFlow; Anda akan menyetel/memodifikasinya
setiap iterasi sampai Anda mendapatkan nilai stabil (benar).
Gambar 4-1. Model linier dasar
Anda perlu membuat placeholder untuk X. Placeholder memiliki tempat khusus

bentuk dan mengandung jenis tertentu.
Ketika Anda memiliki lebih dari satu fitur, Anda akan memiliki fungsi yang serupa
model ke Gambar 4-2.
58
halaman 71
Gambar 4-2. Model linier dengan banyak input
Dalam kode berikut, Anda akan menggunakan kumpulan data Iris dari Seaborn, yang:
memiliki lima atribut. Anda akan mempertimbangkan panjang sepal sebagai input Anda dan
panjang kelopak sebagai nilai keluaran. Tujuan utama dari model regresi ini adalah untuk
memprediksi panjang kelopak ketika Anda diberi nilai panjang sepal. X adalah
panjang sepal, dan Y adalah panjang petal.
Regresi linier menggunakan TensorFlow pada data Iris
59
halaman 72
60
halaman 73
Jika Anda menjalankan kode, Anda akan melihat output yang ditunjukkan pada Gambar 4-3 .
Gambar 4-3. Bobot, bias, dan kerugian di setiap langkah
61
halaman 74
Angka 4-4 menunjukkan plot untuk nilai prediksi panjang kelopak.
Gambar 4-4. Panjang kelopak versus panjang sepal
Model Regresi Logistik

Untuk klasifikasi, pendekatan yang paling sederhana adalah regresi logistik. Di dalam
bagian ini, Anda akan mempelajari bagaimana Anda dapat melakukan regresi logistik dalam
TensorFlow. Di sini Anda membuat bobot dan bias sebagai variabel sehingga ada
adalah ruang lingkup penyetelan/pengubahan mereka per iterasi. Placeholder dibuat
mengandung X. Anda perlu membuat placeholder untuk X. Placeholder memiliki
bentuk tertentu dan berisi jenis tertentu, seperti yang ditunjukkan pada Gambar 4-5 .
Gambar 4-5. Bagan model regresi logistik
62
halaman 75
Dalam kode berikut, Anda akan menggunakan set data Iris, yang memiliki lima:
atribut. Yang kelima adalah kelas sasaran. Anda akan mempertimbangkan sepal
panjang dan lebar sepal sebagai atribut prediktor dan spesies bunga
sebagai nilai sasaran. Tujuan utama dari model regresi logistik ini adalah untuk
memprediksi jenis spesies ketika Anda diberi panjang sepal dan sepal
nilai lebar.
Buat file Python dan impor semua perpustakaan yang diperlukan.
63
halaman 76

Jika Anda menjalankan kode sebelumnya, plot kerugian lintas entropi terhadap masing-masing
zaman terlihat seperti Gambar 4-6 .
64
halaman 77
Gambar 4-6. Plot untuk kehilangan entropi silang per zaman
Perceptron Multilayer di TensorFlow

Perceptron multilayer (MLP) adalah contoh sederhana dari umpan balik buatan
jaringan saraf. Sebuah MLP terdiri dari setidaknya satu lapisan tersembunyi dari node
selain lapisan input dan lapisan output. Setiap simpul dari lapisan selain
lapisan input disebut neuron yang menggunakan fungsi aktivasi nonlinier
seperti sigmoid atau ReLU. MLP menggunakan teknik pembelajaran terawasi yang disebut
backpropagation untuk pelatihan sambil meminimalkan fungsi kerugian seperti
lintas entropi dan menggunakan pengoptimal untuk parameter penyetelan (bobot dan
bias). Beberapa lapisan dan aktivasi non-linearnya membedakan MLP dari a
perseptron linier.
TensorFlow sangat cocok untuk membuat model MLP. Dalam MLP, Anda
perlu menyesuaikan bobot dan bias per iterasi. Ini berarti berat dan
bias terus berubah sampai menjadi stabil sambil meminimalkan kerugian
fungsi. Jadi, Anda dapat membuat bobot dan bias sebagai variabel di TensorFlow.
Saya cenderung memberi mereka nilai awal (semua 0 atau semua 1 atau acak secara normal
nilai terdistribusi). Placeholder harus memiliki jenis nilai tertentu
dan bentuk yang ditentukan, seperti yang ditunjukkan pada Gambar 4-7 .
65
halaman 78
Gambar 4-7. Diagram alir untuk MLP
Impor semua perpustakaan yang diperlukan. Menerapkan MLP di TensorFlow.
66
halaman 79

67
halaman 80
Jika Anda menjalankan kode ini, Anda akan mendapatkan plot yang ditunjukkan pada Gambar 4-8 .
Gambar 4-8. Plot untuk kehilangan saat pelatihan dan pengujian
Dalam bab ini, saya membahas bagaimana Anda dapat membangun linier, logistik, dan MLP
model di TensorFlow secara sistemik.
68
halaman 81
BAB 5
Regresi ke MLP
di Keras
Anda telah mengerjakan regresi sambil menyelesaikan pembelajaran mesin
aplikasi. Regresi linier dan regresi nonlinier digunakan untuk
memprediksi target numerik, sementara regresi logistik dan pengklasifikasi lainnya adalah
digunakan untuk memprediksi variabel target non-numerik. Dalam bab ini, saya akan membahas
evolusi perceptron multilayer.
Secara khusus, Anda akan membandingkan akurasi yang dihasilkan oleh berbagai
model dengan dan tanpa menggunakan Keras.
Model Log-Linear
Buat file Python baru dan impor paket berikut. Yakinkan
Anda telah menginstal Keras di sistem Anda.

69
https://doi.org/10.1007/978-1-4842-3516-4_5
halaman 82
BAB 5 REGRESI MLP DI KERAS
Anda akan menggunakan kumpulan data Iris sebagai sumber data. Jadi, muat
kumpulan data dari Seaborn.
Kumpulan data Iris memiliki lima atribut. Anda akan menggunakan empat yang pertama
atribut untuk memprediksi spesies, yang kelasnya ditentukan dalam atribut kelima
dari kumpulan data.
Menggunakan fungsi scikit-learn, pisahkan set data pengujian dan pelatihan.
#############################################
# scikit Belajar untuk (Log) Regresi Linier #
#############################################
Gunakan fungsi model.fit untuk melatih model dengan pelatihan

Himpunan data.
Saat model dilatih, Anda dapat memprediksi output dari set pengujian.
70
halaman 83
Jaringan Saraf Keras untuk Regresi Linier

Sekarang, mari kita buat model jaringan saraf Keras untuk regresi linier.
Gunakan fungsi model.fit untuk melatih model dengan pelatihan

Himpunan data.
Saat model dilatih, Anda dapat memprediksi output dari set pengujian.
Cetak akurasi yang diperoleh kedua model.

71
halaman 84
Jika Anda menjalankan kode, Anda akan melihat output berikut:
72
halaman 85
Regresi logistik
Di bagian ini, saya akan membagikan contoh untuk regresi logistik sehingga Anda dapat
bandingkan kode di scikit-learn dengan kode di Keras (lihat Gambar 5-1 ).
Gambar 5-1. Regresi logistik yang digunakan untuk klasifikasi

Anda akan menggunakan kumpulan data Iris sebagai sumber data. Jadi, muat
kumpulan data dari scikit-belajar.
Menggunakan fungsi scikit-learn, pisahkan set data pengujian dan pelatihan.
73
halaman 86
scikit-belajar untuk Regresi Logistik

Gunakan fungsi model.fit untuk melatih model dengan kumpulan data pelatihan.
Setelah model dilatih, Anda dapat memprediksi output dari set tes.
##################################################
Jaringan Saraf Keras untuk Regresi Logistik

Encoding sekali pakai mengubah fitur ke format yang berfungsi lebih baik dengan
klasifikasi dan algoritma regresi.
74
halaman 87
Gunakan fungsi model.fit untuk melatih model dengan kumpulan data pelatihan.
Gunakan fungsi model.evaluate untuk mengevaluasi kinerja dari

model.
Cetak akurasi yang diperoleh kedua model.

Akurasi untuk model berbasis scikit-learn
Akurasinya adalah 0,83.

Akurasi untuk model keras
Akurasinya adalah 0,99.
75
halaman 88
Untuk memberikan contoh kehidupan nyata, saya akan membahas beberapa kode yang menggunakan
Kumpulan data Fashion MNIST, yang merupakan kumpulan data gambar Zalando.com
terdiri dari satu set pelatihan 60.000 contoh dan satu set uji 10.000
contoh. Setiap contoh adalah gambar skala abu-abu 28 × 28 yang terkait dengan label
dari sepuluh kelas.
76
halaman 89
Data MNIST Mode: Regresi Logistik

di Keras
Seperti yang disebutkan, Anda akan menggunakan kumpulan data Fashion MNIST. Simpan
data dan label dalam dua variabel yang berbeda.
Normalisasikan kumpulan data, seperti yang ditunjukkan di sini:
77
halaman 90
Tentukan model, seperti yang ditunjukkan di sini:
Simpan model dalam file .h5 (sehingga Anda dapat menggunakannya nanti secara langsung dengan
fungsi load_model() dari keras.models) dan cetak akurasi dari
model di set tes, seperti yang ditunjukkan di sini:
78
halaman 91
Jika Anda menjalankan kode sebelumnya, Anda akan melihat output berikut:
('train-images-idx3-ubyte.gz', <http.client.HTTPMessage objek

di 0x0000171338E2B38>)
_______________________________________________________________
Lapisan (tipe) Bentuk Keluaran Param #
================================================== ===============
padat_59 (Padat) (Tidak ada, 256) 200960
_______________________________________________________________
putus_10 (Keluar) (Tidak ada, 256) 0
_______________________________________________________________
_______________________________________________________________
================================================== ===============
Jumlah parameter: 337.674
Parameter yang dapat dilatih: 337.674
Params yang tidak dapat dilatih: 0
_______________________________________________________________
Latih 60000 sampel, validasi 10.000 sampel
Zaman 1/2
60000/60000 [==============================] - rugi: 0,5188 -
acc: 0,8127 - val_loss: 0,4133 - val_acc: 0,8454
Zaman 2/2
60000/60000 [==============================] - rugi: 0,3976 -
acc: 0,8545 - val_loss: 0,4010 - val_acc: 0,8513
Kerugian uji: 0,400989927697
Akurasi uji: 0,8513
79
halaman 92
MLP di Data Iris

Perceptron multilayer adalah model jaringan saraf minimal. Di dalam
bagian, saya akan menunjukkan kodenya.
Tulis Kodenya
Muat kumpulan data dengan membaca file CSV menggunakan Pandas.
Tetapkan nilai numerik ke kelas kumpulan data.
Mengkonversi bingkai data ke array.
80
halaman 93
Pisahkan data dan target dan simpan dalam dua variabel berbeda.
Ubah format target menggunakan Numpy.
Bangun Model Keras Berurutan

Di sini Anda akan membangun model perceptron multilayer dengan satu lapisan tersembunyi.
• Lapisan input : Lapisan input berisi empat neuron,

mewakili fitur iris (panjang sepal, dll.).
• Lapisan tersembunyi : Lapisan tersembunyi berisi sepuluh neuron,

dan aktivasinya menggunakan ReLU.
• Lapisan keluaran : Lapisan keluaran berisi tiga neuron,

mewakili kelas lapisan softmax Iris.
81
halaman 94
Kompilasi model dan pilih pengoptimal dan fungsi kerugian untuk

melatih dan mengoptimalkan data Anda, seperti yang ditunjukkan di sini:
Latih model menggunakan fungsi model.fit, seperti yang ditunjukkan di sini:
Muat dan siapkan data uji, seperti yang ditunjukkan di sini:
Ubah nilai string menjadi nilai numerik, seperti yang ditunjukkan di sini:
Konversikan bingkai data ke array, seperti yang ditunjukkan di sini:
Pisahkan x dan y, dengan kata lain, set fitur dan set target, seperti yang ditunjukkan di sini:
82
halaman 95
Buat prediksi pada model yang dilatih, seperti yang ditunjukkan di sini:
Hitung akurasi, seperti yang ditunjukkan di sini:
Cetak akurasi yang dihasilkan oleh model, seperti yang ditunjukkan di sini:
Zaman 1/100
120/120 [==============================] - 0 detik - kalah: 2,7240 -
acc: 0,3667
Zaman 2/100
120/120 [==============================] - 0 detik - kalah: 2,4166 -
acc: 0,3667
Zaman 3/100
120/120 [==============================] - 0 detik - kalah: 2.1622 -
acc: 0,4083
Zaman 4/100
120/120 [==============================] - 0 detik - kalah: 1,9456 -
acc: 0,6583
83
halaman 96
Zaman 98/100
120/120 [==============================] - 0 detik - kalah: 0,5571 -
acc: 0,9250
Zaman 99/100
120/120 [==============================] - 0 detik - kalah: 0,5554 -
acc: 0,9250
Zaman 100/100
120/120 [==============================] - 0 detik - kalah: 0,5537 -
acc: 0,9250
MLP pada Data MNIST (Klasifikasi Digit)

MNIST adalah kumpulan data standar untuk memprediksi angka tulisan tangan. Di dalam
bagian, Anda akan melihat bagaimana Anda dapat menerapkan konsep multilayer
perceptron dan membuat sistem pengenalan angka tulisan tangan.
Satu variabel penting didefinisikan.

84
halaman 97
Muat kumpulan data menggunakan fungsi mnist.load_data().
Jenis set pelatihan dan set tes dikonversi ke float32.
Kumpulan data dinormalisasi; dengan kata lain, mereka diatur ke Z-score.
Tampilkan jumlah sampel pelatihan yang ada dalam kumpulan data dan
juga jumlah set tes yang tersedia.
Konversi vektor kelas ke matriks kelas biner.
85
halaman 98
Tentukan model sekuensial dari perceptron multilayer.

Gunakan pengoptimal.
Fungsi untuk mengoptimalkan adalah entropi silang antara label yang sebenarnya
dan output (softmax) dari model.
Gunakan fungsi model.fit untuk melatih model.
Menggunakan model, mengevaluasi fungsi untuk mengevaluasi kinerja

model.
Cetak akurasi yang dihasilkan dalam model.
86
halaman 99
Jika Anda menjalankan kode, Anda akan mendapatkan output berikut:

60000 sampel kereta api
10.000 sampel uji

Latih 60000 sampel, validasi 10.000 sampel
Zaman 1/20
13 detik - rugi: 0,2849 - acc: 0,9132 - val_loss: 0,1149 - val_acc:
0,9652
Zaman 2/20
11 d - rugi: 0,1299 - acc: 0,9611 - val_loss: 0,0880 - val_acc:
0,9741
Zaman 3/20
11 d - rugi: 0,0998 - acc: 0,9712 - val_loss: 0,1121 - val_acc:
0,9671
Zaman 4/20
Zaman 18/20
0,9814
Zaman 19/20
0,9829
Zaman 20/20
0,9824
Skor tes: 0.118255248802
Akurasi uji: 0,9824
Sekarang, saatnya membuat kumpulan data dan menggunakan perceptron multilayer.
Di sini Anda akan membuat kumpulan data Anda sendiri menggunakan fungsi acak dan menjalankan
model perceptron multilayer pada data yang dihasilkan.
87
halaman 100
MLP pada Data yang Dihasilkan Secara Acak

Buat data menggunakan fungsi acak.
Buat model sekuensial.
Kompilasi modelnya.
Gunakan fungsi model.fit untuk melatih model.
88
halaman 101
Evaluasi kinerja model menggunakan model.evaluate

fungsi.
Jika Anda menjalankan kode, Anda akan mendapatkan output berikut:
Zaman 1/20
1000/1000 [==============================] - 0 detik - kalah:
2.4432 - acc: 0.0970
Zaman 2/20
1000/1000 [==============================] - 0 detik - kalah:
2,3927 - perkiraan: 0,0850
Zaman 3/20
1000/1000 [==============================] - 0 detik - kalah:
2.3361 - acc: 0.1190
Zaman 4/20
1000/1000 [==============================] - 0 detik - kalah:
2.3354 - acc: 0.1000
Zaman 19/20
1000/1000 [==============================] - 0 detik - kalah:
2.3034 - acc: 0.1160
Zaman 20/20
1000/1000 [==============================] - 0 detik - kalah:
2.3055 - acc: 0.0980
100/100 [==============================] - 0s
Dalam bab ini, saya membahas bagaimana membangun linier, logistik, dan MLP
model di Keras secara sistemik.
89
halaman 102
BAB 6
saraf konvolusi
Jaringan
Sebuah jaringan saraf convolutional (CNN) adalah umpan-maju, buatan dalam
jaringan saraf di mana jaringan saraf mempertahankan hierarki
struktur dengan mempelajari representasi fitur internal dan menggeneralisasikan
fitur dalam masalah gambar umum seperti pengenalan objek dan lainnya
masalah penglihatan komputer. Ini tidak terbatas pada gambar; itu juga mencapai
hasil mutakhir dalam masalah pemrosesan bahasa alami dan
pengenalan suara.
Lapisan berbeda di CNN

CNN terdiri dari beberapa lapisan, seperti yang ditunjukkan pada Gambar 6-1 .
Gambar 6-1. Lapisan dalam jaringan saraf konvolusi

https://doi.org/10.1007/978-1-4842-3516-4_6
Halaman 103
Bab 6 Jaringan saraf konvolusi
Lapisan konvolusi terdiri dari filter dan peta gambar. Pertimbangkan

gambar input grayscale memiliki ukuran 5 × 5, yang merupakan matriks 25 piksel
nilai-nilai. Data gambar dinyatakan sebagai matriks tiga dimensi dari
lebar × tinggi × saluran.
Catatan Peta gambar adalah daftar koordinat yang berkaitan dengan titik tertentu
gambar.
Konvolusi bertujuan untuk mengekstrak fitur dari gambar input, dan

karenanya mempertahankan hubungan spasial antara piksel dengan belajar
fitur gambar menggunakan kotak kecil data input. invarian rotasi,
invarian translasi, dan invarians skala dapat diharapkan. Sebagai contoh,
gambar kucing yang diputar atau gambar kucing yang diskalakan ulang dapat dengan mudah diidentifikasi dengan a
CNN karena langkah konvolusi. Anda menggeser filter (matriks persegi)
di atas gambar asli Anda (di sini, 1 piksel), dan pada setiap posisi tertentu, Anda
menghitung perkalian elemen-bijaksana (antara matriks filter
dan gambar asli) dan tambahkan hasil perkalian untuk mendapatkan hasil akhir
bilangan bulat yang membentuk elemen matriks keluaran.
Subsampling hanyalah penyatuan rata-rata dengan bobot yang dapat dipelajari per
peta fitur, seperti yang ditunjukkan pada Gambar 6-2 .
92
halaman 104
Gambar 6-2. Subsampling
Seperti yang ditunjukkan pada Gambar 6-2 , filter memiliki bobot masukan dan menghasilkan
neuron keluaran. Katakanlah Anda mendefinisikan lapisan konvolusi dengan enam filter
dan bidang reseptif dengan lebar 2 piksel dan tinggi 2 piksel dan menggunakan a
lebar langkah default 1, dan padding default diatur ke 0. Setiap filter
menerima input dari 2x2 piksel, bagian gambar. Dengan kata lain, itu 4
piksel pada suatu waktu. Oleh karena itu, Anda dapat mengatakan itu akan membutuhkan bobot input 4 + 1 (bias).
Volume input adalah 5 × 5 × 3 (lebar × tinggi × jumlah saluran), di sana
enam filter berukuran 2×2 dengan langkah 1 dan pad 0. Oleh karena itu, jumlah
parameter di lapisan ini untuk setiap filter memiliki 2*2*3 + 1 = 13 parameter (ditambahkan
+1 untuk bias). Karena ada enam filter, Anda mendapatkan 13*6 = 78 parameter.
93
halaman 105
Gambar 6-3. Volume masukan
Berikut ringkasannya:
• Volume input berukuran W1 × H1 × D1.
• Model membutuhkan hyperparameters: jumlah

filter (f ), langkah (S), jumlah bantalan nol (P).
• Ini menghasilkan volume ukuran W2 × H2 × D2.
• W2 = (W1-f+ 2P) /S + 1 = 4.
• H2 = (H1-f+2P)/S +1 = 4.
• D2 = Jumlah filter = f = 6.
Lapisan penyatuan mengurangi peta aktivasi lapisan sebelumnya. Dia

diikuti oleh satu atau lebih lapisan konvolusi dan menggabungkan semua
fitur yang dipelajari di peta aktivasi lapisan sebelumnya. Ini
mengurangi overfitting data pelatihan dan menggeneralisasi fitur
diwakili oleh jaringan. Ukuran bidang reseptif hampir selalu disetel ke
2×2 dan gunakan langkah 1 atau 2 (atau lebih tinggi) untuk memastikan tidak ada tumpang tindih. Anda
akan menggunakan operasi maks untuk setiap bidang reseptif sehingga aktivasinya adalah
nilai masukan maksimum. Di sini, setiap empat angka dipetakan menjadi satu angka saja.
Jadi, jumlah piksel turun menjadi seperempat dari aslinya dalam hal ini
langkah (Gambar 6-4 ).
94
halaman 106
Gambar 6-4. Maxpooling-mengurangi jumlah piksel
Lapisan yang sepenuhnya terhubung adalah jaringan saraf tiruan feed-forward

lapisan. Lapisan-lapisan ini memiliki fungsi aktivasi nonlinier ke kelas keluaran
probabilitas prediksi. Mereka digunakan menjelang akhir setelah semua fitur
diidentifikasi dan diekstraksi oleh lapisan konvolusi dan telah
dikonsolidasikan oleh lapisan penyatuan dalam jaringan. Di sini, yang tersembunyi dan
lapisan output adalah lapisan yang terhubung penuh.
Arsitektur CNN
CNN adalah arsitektur jaringan saraf dalam feed-forward yang terdiri dari:
beberapa lapisan konvolusi, masing-masing diikuti oleh lapisan penyatuan, aktivasi
fungsi, dan normalisasi batch opsional. Ini juga terdiri dari
lapisan yang terhubung penuh. Saat sebuah gambar bergerak melalui jaringan, ia mendapatkan
lebih kecil, sebagian besar karena max pooling. Lapisan terakhir menampilkan kelas
prediksi probabilitas.
95
halaman 107
Gambar 6-5. Arsitektur CNN untuk Klasifikasi
Beberapa tahun terakhir telah melihat banyak arsitektur yang dikembangkan

yang telah membuat kemajuan luar biasa di bidang klasifikasi citra.
Jaringan pra-pelatihan pemenang penghargaan (VGG16, VGG19, ResNet50, Inception
V3, dan Xception) telah digunakan untuk berbagai klasifikasi gambar
tantangan termasuk pencitraan medis. Pembelajaran transfer adalah jenis
berlatih di mana Anda menggunakan model pra-latihan selain beberapa lapisan.
Ini dapat digunakan untuk menyelesaikan tantangan klasifikasi gambar di setiap bidang.
96
halaman 108
BAB 7
CNN di TensorFlow
Bab ini akan menunjukkan cara menggunakan TensorFlow untuk membangun CNN
model. Model CNN dapat membantu Anda membuat pengklasifikasi gambar yang dapat
memprediksi/mengklasifikasikan gambar. Secara umum, Anda membuat beberapa lapisan dalam model
arsitektur dengan nilai awal bobot dan bias. Kemudian Anda menyesuaikan berat badan
dan bias dengan bantuan kumpulan data pelatihan. Ada pendekatan lain
yang melibatkan penggunaan model yang telah dilatih sebelumnya seperti InceptionV3 untuk mengklasifikasikan
gambar. Anda dapat menggunakan pendekatan pembelajaran transfer ini di mana Anda menambahkan
beberapa lapisan (yang parameternya dilatih) di atas lapisan yang telah dilatih sebelumnya
model (dengan nilai parameter utuh) untuk membuat pengklasifikasi yang sangat kuat.
Dalam bab ini, saya akan menggunakan TensorFlow untuk menunjukkan cara mengembangkan
jaringan konvolusi untuk berbagai aplikasi visi komputer. Lebih mudah
untuk mengekspresikan arsitektur CNN sebagai grafik aliran data.
Mengapa TensorFlow untuk Model CNN?

Di TensorFlow, gambar dapat direpresentasikan sebagai array tiga dimensi
atau tensor bentuk (tinggi, lebar dan saluran). TensorFlow menyediakan
fleksibilitas untuk melakukan iterasi dengan cepat, memungkinkan Anda melatih model lebih cepat, dan
memungkinkan Anda menjalankan lebih banyak eksperimen. Saat menggunakan model TensorFlow untuk
produksi, Anda dapat menjalankannya pada GPU dan TPU skala besar.

https://doi.org/10.1007/978-1-4842-3516-4_7
halaman 109
BAB 7 CNN DALAM TENSORFLOW
Kode TensorFlow untuk Membangun Gambar

Pengklasifikasi untuk Data MNIST
Di bagian ini, saya akan membawa Anda melalui sebuah contoh untuk memahami bagaimana caranya
mengimplementasikan CNN di TensorFlow.
Kode berikut mengimpor set data MNIST dengan skala abu-abu 28 × 28
gambar digit dari paket kontribusi TensorFlow dan memuat semua
perpustakaan yang dibutuhkan. Di sini, tujuannya adalah untuk membangun pengklasifikasi untuk memprediksi digit
diberikan dalam gambar.
dari tensorflow.contrib.learn.python.learn.datasets.mnist
impor read_data_sets
dari operasi impor tensorflow.python.framework
impor tensorflow sebagai tf
impor numpy sebagai np
Anda kemudian memulai sesi grafik.
# Mulai sesi grafik

sess = tf.Session()
Anda memuat data MNIST dan membuat rangkaian kereta dan pengujian.
# Muat data
dari keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()
Anda kemudian menormalkan fitur rangkaian kereta dan pengujian.
# Skor Z atau Normalisasi Gaussian

X_train = X_train - np.mean(X_train) / X_train.std()
X_test = X_test - np.mean(X_test) / X_test.std()
Karena ini adalah masalah klasifikasi multiclass, selalu lebih baik untuk digunakan
pengkodean satu-panas dari nilai-nilai kelas keluaran.
98
halaman 110
# Ubah label menjadi vektor enkode satu-panas

jumlah_kelas = 10
train_labels = tf.one_hot(y_train, num_class)
test_labels = tf.one_hot(y_test, num_class)
Mari kita atur parameter model sekarang karena gambar ini berwarna abu-abu.
Oleh karena itu, kedalaman gambar (saluran) adalah 1.
# Setel parameter model

batch_size = 784
sampel = 500
learning_rate = 0,03
img_width = X_train[0].shape[0]
img_height = X_train[0].shape[1]
target_size = max(train_labels) + 1
jumlah_saluran = 1 # skala abu-abu = 1 saluran
zaman = 200
no_channel = 1
fitur_konv1 = 30
filt1_features = 5
fitur_konv2 = 15
filt2_features = 3
max_pool_size1 = 2 # Jendela NxN untuk lapisan kolam maksimum pertama
max_pool_size2 = 2 # Jendela NxN untuk lapisan kolam maks ke-2
full_connected_size1 = 150
99
halaman 111
Mari kita nyatakan placeholder untuk model. Fitur input data,

variabel target, dan ukuran batch dapat diubah untuk pelatihan dan
set evaluasi.
# Deklarasikan placeholder model

x_input_shape = (ukuran_batch, img_width, img_height, num_channels)
x_input = tf.placeholder(tf.float32, bentuk=x_input_shape)
y_target = tf.placeholder(tf.int32, bentuk=(batch_size))
eval_input_shape = (sampel, img_width, img_height, num_channels)
eval_input = tf.placeholder(tf.float32, bentuk=eval_input_shape)
eval_target = tf.placeholder(tf.int32, shape=(sampel))
Mari kita nyatakan nilai bobot dan bias variabel model untuk input dan
neuron lapisan tersembunyi.
# Deklarasikan variabel model

W1 = tf.Variable(tf.random_normal([filt1_features,
filt1_features, no_channels, conv1_features]))
b1 = tf.Variable(tf.ones([conv1_features]))
W2 = tf.Variable(tf.random_normal([filt2_features,
filt2_features, conv1_features, conv2_features]))
b2 = tf.Variable(tf.ones([conv2_features]))
Mari kita deklarasikan variabel model untuk layer yang terhubung penuh dan definisikan
bobot dan bias untuk 2 lapisan terakhir ini.
# Deklarasikan variabel model untuk lapisan yang terhubung penuh

result_width = img_width // (max_pool_size1 * max_pool_size2)
result_height = img_height // (max_pool_size1 * max_pool_size2)
full1_input_size = result_width * result_height * conv2_
fitur
W3 = tf.Variable(tf.truncated_normal([full1_input_size,
full_connected_size1], stddev=0.1, dtype=tf.float32))
100
halaman 112
b3 = tf.Variable(tf.truncated_normal([full_connected_size1],
stddev=0.1, dtype=tf.float32))
W_out = tf.Variable(tf.truncated_normal([full_connected_size1,
target_size], stddev=0.1, dtype=tf.float32))
b_out = tf.Variable(tf.truncated_normal([target_size],
stddev=0.1, dtype=tf.float32))
Mari kita buat fungsi pembantu untuk mendefinisikan konvolusi dan maks
lapisan penyatuan.
# Tentukan fungsi pembantu untuk lapisan konvolusi dan maxpool:

def conv_layer(x, W, b):
konv = tf.nn.conv2d(x, W, langkah=[1, 1, 1, 1],
padding = 'SAMA')
konv_dengan_b = tf.nn.bias_add(konv, b)
conv_out = tf.nn.relu(conv_with_b)
kembalikan konv_out
def maxpool_layer(konv, k=2):
kembali tf.nn.max_pool(conv, ksize=[1, k, k, 1],
langkah=[1, k, k, 1], padding='SAMA')
Sebuah model jaringan saraf didefinisikan dengan dua lapisan tersembunyi dan dua lapisan
lapisan yang terhubung penuh. Unit linier yang diperbaiki digunakan sebagai aktivasi
berfungsi untuk lapisan tersembunyi dan lapisan keluaran akhir.
# Inisialisasi Operasi Model

def my_conv_net(data_input):
# Lapisan Conv-ReLU-MaxPool Pertama
conv_out1 = conv_layer(data_input, W1, b1)
maxpool_out1 = maxpool_layer(conv_out1)
101
halaman 113
# Lapisan Conv-ReLU-MaxPool Kedua

conv_out2 = conv_layer(maxpool_out1, W2, b2)
maxpool_out2 = maxpool_layer(conv_out2)
# Ubah Output menjadi lapisan 1xN untuk selanjutnya sepenuhnya

lapisan terhubung
final_conv_shape = maxpool_out2.get_shape().as_list()
final_shape = final_conv_shape[1] * final_conv_shape[2] *
bentuk_konv_akhir[3]
flat_output = tf.reshape(maxpool_out2, [final_conv_shape[0],
bentuk_akhir])
# Lapisan Pertama yang Terhubung Sepenuhnya

sepenuhnya_terhubung1 = tf.nn.relu(tf.add(tf.matmul(flat_output,
W3), b3))
# Lapisan Kedua Terhubung Sepenuhnya
final_model_output = tf.add(tf.matmul(full_connected1,
W_out), b_out)
kembali (keluaran_model_akhir)
model_output = my_conv_net(x_input)
test_model_output = my_conv_net(eval_input)
Anda akan menggunakan fungsi entropi lintas softmax (cenderung bekerja lebih baik untuk
klasifikasi multiclass) untuk menentukan kerugian yang beroperasi pada log.
# Deklarasikan Fungsi Rugi (softmax cross entropy)

rugi = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_
logits(logits=model_output, labels=y_target))
Mari kita definisikan fungsi prediksi rangkaian kereta dan tes.
# Buat fungsi prediksi

prediksi = tf.nn.softmax(model_output)
test_prediction = tf.nn.softmax(test_model_output)
102
halaman 114
Untuk menentukan akurasi model pada setiap batch, mari kita definisikan
fungsi akurasi.
# Buat fungsi akurasi

def get_accuracy(logit, target):
batch_predictions = np.argmax(logits, axis=1)
num_correct = np.sum(np.equal(batch_predictions, target))
return(100. * num_correct/batch_predictions.shape[0])
Mari deklarasikan langkah pelatihan dan definisikan fungsi pengoptimal.
# Buat pengoptimal
my_optimizer = tf.train.AdamOptimizer(learning_rate, 0.9)
train_step = my_optimizer.minimize(rugi)
Mari kita inisialisasi semua variabel model yang dideklarasikan sebelumnya.
# Inisialisasi Variabel
varInit = tf.global_variables_initializer()
sess.run(varInit)
Mari kita mulai melatih model dan mengulang secara acak melalui batch
dari data. Anda ingin mengevaluasi model di kereta dan menguji kumpulan kumpulan
dan mencatat kehilangan dan akurasi.
# Mulai putaran pelatihan

kereta_rugi = []
kereta_acc = []
tes_acc = []
untuk saya dalam jangkauan (Epoch):
random_index = np.random.choice(len(X_train), size=batch_size)
random_x = X_train[random_index]
random_x = np.expand_dims(random_x, 3)
random_y = train_labels[random_index]
train_dict = {x_input: random_x, y_target: random_y}
103
halaman 115
sess.run(train_step, feed_dict=train_dict)
temp_train_loss, temp_train_preds = sess.run([rugi,
prediksi], feed_dict=train_dict)
temp_train_acc = get_accuracy(temp_train_preds, random_y)
eval_index = np.random.choice(len(X_test),
ukuran=ukuran_evaluasi)
eval_x = X_test[eval_index]
eval_x = np.expand_dims(eval_x, 3)
eval_y = test_labels[eval_index]
test_dict = {eval_input: eval_x, eval_target: eval_y}
test_preds = sess.run(test_prediction, feed_dict=test_dict)
temp_test_acc = get_accuracy(test_preds, eval_y)
Hasil model dicatat dalam format berikut dan

dicetak dalam output:
# Rekam dan cetak hasil

train_loss.append(temp_train_loss)
train_acc.append(temp_train_acc)
test_acc.append(temp_test_acc)
print('Epoch # {}. Rugi Kereta: {:.2f}. Kereta Acc : {:.2f} .
temp_test_acc : {:.2f}'.format(i+1,temp_train_loss,
temp_train_acc,temp_test_acc))
Menggunakan API Tingkat Tinggi untuk Membangun CNN

Model
TFLearn, TensorLayer, tflayers, TF-Slim, tf.contrib.learn, Pretty Tensor,
keras, dan Sonnet adalah API TensorFlow tingkat tinggi. Jika Anda menggunakan salah satu dari ini
API tingkat tinggi, Anda dapat membuat model CNN dalam beberapa baris kode. Jadi kamu
dapat menjelajahi salah satu API ini untuk bekerja dengan cerdas.
104
halaman 116
BAB 8
CNN di Keras
Bab ini akan menunjukkan bagaimana menggunakan Keras untuk membangun model CNN.
Model CNN dapat membantu Anda membangun pengklasifikasi gambar yang dapat memprediksi
dan mengklasifikasikan gambar. Secara umum, Anda membuat beberapa lapisan dalam model
arsitektur dengan nilai awal bobot dan bias. Kemudian Anda menyetel
variabel bobot dan bias dengan bantuan kumpulan data pelatihan. Kamu akan
pelajari cara membuat kode di Keras dalam konteks ini. Ada pendekatan lain yang
melibatkan penggunaan model terlatih seperti InceptionV3 dan ResNet50 yang
dapat mengklasifikasikan gambar.
Mari kita definisikan model CNN dan mengevaluasi seberapa baik kinerjanya. Anda
akan menggunakan struktur dengan lapisan konvolusi; maka Anda akan menggunakan maks
menyatukan dan meratakan jaringan untuk sepenuhnya menghubungkan lapisan dan membuat
prediksi.
Membangun Pengklasifikasi Gambar untuk Data MNIST

di Keras
Di sini saya akan mendemonstrasikan proses membangun classifier untuk tulisan tangan
digit menggunakan kumpulan data MNIST yang populer.
Tugas ini merupakan tantangan besar untuk bermain dengan jaringan saraf, tetapi bisa
dikelola pada satu komputer.
Basis data MNIST berisi 60.000 gambar pelatihan dan 10.000
pengujian gambar.

https://doi.org/10.1007/978-1-4842-3516-4_8
halaman 117
BAB 8 CNN DI KERAS
Mulailah dengan mengimpor Numpy dan menyetel benih untuk komputer

pembangkit bilangan pseudorandom. Ini memungkinkan Anda untuk mereproduksi hasil
dari skrip Anda.
# benih acak untuk reproduktifitas
np.random.seed(123)
Selanjutnya, Anda mengimpor tipe model sekuensial dari Keras. Ini hanya
tumpukan linier lapisan jaringan saraf.
dari keras.models import Sequential

dari keras.layers impor Padat
dari keras.layers impor Dropout
dari keras.layers import Flatten
dari keras.layers impor Conv2D
dari keras.layers impor MaxPooling2d
#Sekarang kita akan mengimpor beberapa utilitas
dari keras.utils impor np_utils
#Memperbaiki masalah pemesanan dimensi
K.set_image_dim_ordering('th')
#Muat data gambar dari MNIST
#Muat data MNIST yang telah diacak sebelumnya ke dalam rangkaian kereta dan pengujian
(X_train,y_train),(X_test, y_test)=mnist.load_data()
#Praproses data imput untuk Keras

# Bentuk ulang data masukan.
# bentuk ulang menjadi [sampel][saluran][lebar][tinggi]
X_train=X_train.reshape(X_train.shape[0],1,28,28)
X_test=X_test.reshape(X_test.shape[0],1,28,28)
106
halaman 118
BAB 8 CNN DI KERAS
# untuk mengonversi tipe data kami ke float32 dan menormalkan database kami
X_train=X_train.astype('float32')
X_test=X_test.astype('float32')
cetak(X_train.shape)
# Skor-Z atau Normalisasi Gaussian

X_train=X_train - np.mean(X_train) / X_train.std()
X_test=X_test – np.mean(X_test) / X_test.std()
#(60000, 1, 28, 28)
# mengonversi array kelas 1-redup menjadi 10 metrik kelas redup

#satu keluaran penyandian panas
y_train=np_utils.to_categorical(y_train)
y_test-np_utils.to_categorical(y_test)
num_classes=y_test.shape[1]
cetak(jumlah_kelas)
#10
#Tentukan model CNN sederhana

#(60000,1,28,28)
Tentukan Struktur Jaringan
Struktur jaringannya adalah sebagai berikut:
• Jaringan memiliki lapisan input konvolusi, dengan 32 fitur

peta dengan ukuran 5×5. Fungsi aktivasinya adalah
unit linier yang diperbaiki.
• Lapisan kolam maksimal memiliki ukuran 2×2.
• Putus sekolah diatur menjadi 30 persen.
• Anda bisa meratakan layer.
107
halaman 119
BAB 8 CNN DI KERAS
• Jaringan memiliki lapisan yang terhubung penuh dengan 240 unit,

dan fungsi aktivasi adalah unit linier eksponensial.
• Lapisan terakhir jaringan adalah lapisan keluaran yang terhubung penuh

dengan sepuluh unit, dan fungsi aktivasinya adalah softmax.
Kemudian Anda mengkompilasi model dengan menggunakan entropi silang biner sebagai kerugiannya
fungsi dan adagrad sebagai pengoptimal.
Tentukan Arsitektur Model

Arsitektur terdiri dari kombinasi lapisan convolutional dan
lapisan pooling maks dan lapisan padat di ujungnya.
#buat model
model=Sekuensial()
model.add(Conv2D(32, (5,5), input_shape=(1,28,28),
aktivasi = 'relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.3)) # Dropout, salah satu bentuk dari
regularisasi
model.tambahkan(Ratakan())
model.add(Padat(240,aktivasi='elu'))
model.add(Dense(num_classes, activation='softmax'))
cetak(model.output_shape)
(Tidak ada, 10)
# Kompilasi modelnya
model.compile(loss='binary_crossentropy', pengoptimal='adagrad',
matriks=['akurasi'])
108
halaman 120
BAB 8 CNN DI KERAS
Kemudian Anda menyesuaikan model dengan menggunakan set data pelatihan dengan mengambil
ukuran batch 200. Model mengambil 200 instance/baris pertama (dari tanggal 1
ke 200) dari kumpulan data pelatihan dan melatih jaringan. Kemudian
model membutuhkan 200 instans kedua (dari tanggal 201 hingga ke-400) untuk
jaringan pelatihan lagi. Dengan cara ini, Anda menyebarkan semua contoh melalui
jaringan. Model ini membutuhkan lebih sedikit memori saat Anda melatih jaringan dengan
lebih sedikit contoh setiap kali. Tetapi ukuran batch kecil tidak menawarkan yang bagus
perkiraan gradien, dan karenanya penyetelan bobot dan bias dapat menjadi
tantangan.
Satu zaman berarti satu maju pass dan satu lulus mundur dari semua yang
contoh pelatihan. Dibutuhkan beberapa iterasi untuk menyelesaikan satu epoch.
Di sini, Anda memiliki 60.000 contoh pelatihan, dan ukuran batch Anda adalah 200, jadi
dibutuhkan 300 iterasi untuk menyelesaikan 1 epoch.
# Sesuaikan modelnya
model.fit(X_train, y_train, validasi_data=(X_test, y_test),
zaman = 1, ukuran_batch = 200)
# Evaluasi model pada data uji

# Evaluasi akhir model
skor =model.evaluate(X_test, y_test, verbose=0)
print("CNN error: % .2f%%" % (100-skor[1]*100))
# Kesalahan CNN: 17,98%
# Simpan modelnya
# simpan model
model_json= model.to_join()
dengan open("model_json", "w") sebagai json_file:
json_file.write(model_json)
# membuat serial bobot ke HDFS
model.save_weights("model.h5")
109
Halaman 121
Bab 8 CNN di Keras
Membangun Pengklasifikasi Gambar dengan CIFAR-10

Data
Bagian ini menjelaskan bagaimana Anda dapat membangun classifier yang dapat mengklasifikasikan sepuluh
label dari kumpulan data CIFAR-10 menggunakan model CNN Keras.
Perhatikan bahwa kumpulan data CiFar-10 terdiri dari 60.000 warna 32×32
gambar dalam 10 kelas, dengan 6.000 gambar per kelas. ada 50.000
gambar pelatihan dan 10.000 gambar uji.
###########Membangun Model CNN dengan data CIFAR10##################

# plot cifar10 instance
dari keras.datasets impor cifar10
dari matplotlib impor pyplot
dari scipy.misc impor ke gambar
impor numpy
dari keras.layers impor Dropout
dari keras.layers import Flatten
dari keras.layers impor Conv2D
dari keras.layers impor MaxPooling2d
#Sekarang kita akan mengimpor beberapa utilitas
dari keras.utils impor np_utils
dari keras.layers.normalization impor BatchNormalization
#Memperbaiki masalah pemesanan dimensi

K.set_image_dim_ordering('th')
# perbaiki benih acak untuk reproduktifitas

benih = 12
110
Halaman 122
Bab 8 CNN di Keras
numpy.random.seed(biji)
#Praproses data imput untuk Keras
# Bentuk ulang data masukan.
# bentuk ulang menjadi [sampel][saluran][lebar][tinggi]
X_train=X_train.reshape(X_train.shape[0],3,32,32).
astype('float32')
X_test=X_test.reshape(X_test.shape[0],3,32,32).
astype('float32')
# Skor-Z atau Normalisasi Gaussian

X_train=X_train - np.mean(X_train) / X_train.std()
X_test=X_test – np.mean(X_test) / X_test.std()
# mengonversi array kelas 1-redup menjadi 10 metrik kelas redup

#satu keluaran penyandian panas
y_train=np_utils.to_categorical(y_train)
y_test-np_utils.to_categorical(y_test)
num_classes=y_test.shape[1]
cetak(jumlah_kelas)
#10
#Tentukan model CNN sederhana

#(50000,3,32,32)
Tentukan Struktur Jaringan

Struktur jaringannya adalah sebagai berikut:
• Lapisan input convolutional memiliki 32 peta fitur dengan

ukuran 5 × 5, dan fungsi aktivasi diperbaiki
satuan linier.
111
halaman 123
Bab 8 CNN di Keras
• Lapisan konvolusi memiliki 32 peta fitur dengan ukuran

dari 5 × 5, dan fungsi aktivasinya adalah linear terkoreksi
satuan.
• Jaringan memiliki normalisasi batch.
• Putus sekolah diatur menjadi 30 persen.
• Anda bisa meratakan layer.
• Lapisan yang terhubung penuh memiliki 240 unit, dan

fungsi aktivasi adalah unit linier eksponensial.
• Lapisan keluaran yang terhubung penuh memiliki sepuluh unit, dan

fungsi aktivasi adalah softmax.
Kemudian Anda menyesuaikan model dengan menggunakan set data pelatihan dengan mengambil
ukuran batch 200. Anda mengambil 200 instance/baris pertama (dari tanggal 1 hingga
ke-200) dari kumpulan data pelatihan dan latih jaringan. Kemudian Anda mengambil
200 instance kedua (dari tanggal 201 hingga 400) untuk melatih jaringan
lagi. Dengan cara ini, Anda menyebarkan semua instance melalui jaringan. Satu
epoch berarti satu operan ke depan dan satu operan ke belakang dari semua latihan
contoh. Dibutuhkan beberapa iterasi untuk menyelesaikan satu epoch.
Di sini, Anda memiliki 50.000 contoh pelatihan, dan ukuran batch Anda adalah 200, jadi
dibutuhkan 250 iterasi untuk menyelesaikan 1 epoch.
Tentukan Arsitektur Model

Model sekuensial dibuat dengan kombinasi konvolusi dan
lapisan penyatuan maksimal. Kemudian lapisan padat yang terhubung penuh terpasang.
#buat model
model=Sekuensial()
model.add(Conv2D(32, (5,5), input_shape=(3,32,32),
aktivasi = 'relu'))
112
halaman 124
Bab 8 CNN di Keras
model.add(Conv2D(32, (5,5), activation='relu',
padding = 'sama'))
model.add(BatchNormalization())
model.add(Dropout(0.3)) # Dropout, salah satu bentuk dari
regularisasi
model.tambahkan(Ratakan())
model.add(Padat(240,aktivasi='elu'))
model.add(Dense(num_classes, activation='softmax'))
cetak(model.output_shape)
model.compile(loss='binary_crossentropy', pengoptimal='adagrad')
#model pas
model.fit(X_train, y_train, validasi_data=(X_test,
y_test), epochs=1, batch_size=200)
# Evaluasi akhir model

skor =model.evaluate(X_test, y_test, verbose=0)
print("CNN error: % .2f%%" % (100-skor[1]*100
Model Terlatih
Di bagian ini, saya akan menunjukkan bagaimana Anda dapat menggunakan model pra-latihan seperti
VGG dan awal untuk membangun classifier.
113
halaman 125
Bab 8 CNN di Keras
Model pra-pelatihan Inception-V3 dapat mendeteksi/mengklasifikasikan objek 22.000

kategori. Hal ini dapat mendeteksi/mengklasifikasikan nampan, obor, payung dan lain-lain.
Dalam banyak skenario, kita perlu membangun pengklasifikasi sesuai kebutuhan kita.
Untuk itu digunakan transfer learning dimana kita menggunakan model pra latih (used
untuk ekstraksi fitur) dan multiple neural.
114
halaman 126
BAB 9
RNN dan LSTM

Bab ini akan membahas konsep jaringan saraf berulang (RNNs)
dan versi modifikasinya, long short-term memory (LSTM). LSTM adalah
terutama digunakan untuk prediksi urutan. Anda akan belajar tentang varietas
prediksi urutan dan kemudian pelajari cara melakukan peramalan deret waktu dengan
bantuan model LSTM.
Konsep RNN
Sebuah jaringan saraf berulang adalah jenis jaringan saraf tiruan yang terbaik
cocok untuk mengenali pola dalam urutan data, seperti teks, video,
pidato, bahasa, genom, dan data deret waktu. RNN sangat
algoritma yang kuat yang dapat mengklasifikasikan, mengelompokkan, dan membuat prediksi tentang
data, khususnya deret waktu dan teks.
RNN dapat dilihat sebagai jaringan MLP dengan penambahan loop ke
Arsitektur. Pada Gambar 9-1 , Anda dapat melihat bahwa ada lapisan input (dengan
node seperti x1, x2, dan seterusnya), lapisan tersembunyi (dengan node seperti h1,
h2, dan seterusnya), dan lapisan keluaran (dengan node seperti y1, y2, dan seterusnya).
Ini mirip dengan arsitektur MLP. Perbedaannya adalah bahwa node
dari lapisan tersembunyi saling berhubungan. Dalam RNN/LSTM vanilla (dasar),
node terhubung dalam satu arah. Ini berarti bahwa h2 tergantung pada h1
(dan x2), dan h3 bergantung pada h2 (dan x3). Node di lapisan tersembunyi adalah
ditentukan oleh node sebelumnya di lapisan tersembunyi.

https://doi.org/10.1007/978-1-4842-3516-4_9
halaman 127
Bab 9 rNN dan LStM

Gambar 9-1. Sebuah RNN
Jenis arsitektur ini memastikan bahwa output pada t=n bergantung pada
masukan pada t=n, t=n-1, …, dan t=1. Dengan kata lain, output tergantung pada
urutan data daripada satu bagian data (Gambar 9-2 ).
Gambar 9-2. Urutannya
116
halaman 128
Bab 9 rNN dan LStM
Angka 9-3 menunjukkan bagaimana node dari lapisan tersembunyi terhubung ke

node dari lapisan input.
Gambar 9-3. Koneksi
Dalam RNN, jika urutannya cukup panjang, gradien (yang

penting untuk menyetel bobot dan bias) dihitung selama
pelatihan (propagasi balik). Mereka juga menghilang (perkalian banyak
nilai kecil kurang dari 1) atau meledak (perkalian banyak nilai besar
lebih dari 1), menyebabkan model berlatih sangat lambat.
117
halaman 129
Bab 9 rNN dan LStM
Konsep LSTM
Memori jangka pendek panjang adalah arsitektur RNN yang dimodifikasi yang menangani
masalah menghilangnya dan meledaknya gradien dan mengatasi
masalah pelatihan selama urutan panjang dan mempertahankan memori. Semua RNN
memiliki loop umpan balik di lapisan berulang. Loop umpan balik membantu
menyimpan informasi dalam "memori" dari waktu ke waktu. Tapi, itu bisa sulit untuk dilatih
RNN standar untuk memecahkan masalah yang membutuhkan pembelajaran temporal jangka panjang
dependensi. Karena gradien fungsi kerugian meluruh secara eksponensial
dengan waktu (fenomena yang dikenal sebagai masalah gradien lenyap ), itu
sulit untuk melatih RNN tipikal. Itulah mengapa RNN dimodifikasi dengan cara
bahwa itu termasuk sel memori yang dapat menyimpan informasi dalam memori
untuk jangka waktu yang lama. RNN yang dimodifikasi lebih dikenal sebagai LSTM. Di dalam
LSTM, satu set gerbang digunakan untuk mengontrol ketika informasi memasuki memori,
yang memecahkan masalah gradien menghilang atau meledak.
Koneksi berulang menambahkan status atau memori ke jaringan dan
memungkinkannya untuk belajar dan memanfaatkan sifat pengamatan yang teratur di dalam
urutan masukan. Memori internal berarti output dari jaringan adalah
tergantung pada konteks terbaru dalam urutan input, bukan apa yang baru saja
disajikan sebagai input ke jaringan.
Mode LSTM
LSTM dapat memiliki salah satu mode berikut:
• Model satu-ke-satu
• Model satu-ke-banyak
• Model banyak-ke-satu
• Model banyak-ke-banyak
Selain mode ini, model banyak-ke-banyak yang disinkronkan juga

digunakan, terutama untuk klasifikasi video.
118
halaman 130
Bab 9 rNN dan LStM
Angka 9-4 menunjukkan LSTM banyak-ke-satu. Ini menyiratkan bahwa banyak input
membuat satu output dalam model ini.
Gambar 9-4. LSTM banyak-ke-satu
Prediksi Urutan
LSTM paling cocok untuk data urutan. LSTM dapat memprediksi, mengklasifikasikan, dan
menghasilkan data urutan. Sebuah urut berarti urutan pengamatan,
daripada serangkaian pengamatan. Contoh deret adalah deret uji
di mana stempel waktu dan nilai berada dalam urutan (secara kronologis) dari
urutannya. Contoh lain adalah video, yang dapat dianggap sebagai
urutan gambar atau urutan klip audio.
Prediksi berdasarkan urutan data disebut urutan
prediksi . Prediksi urutan dikatakan memiliki empat jenis.
• Prediksi numerik urutan
• Klasifikasi urutan
• Pembuatan urutan
• Prediksi urutan-ke-urutan
119
halaman 131
Bab 9 rNN dan LStM
Prediksi Angka Urutan

Prediksi numerik urutan memprediksi nilai berikutnya untuk yang diberikan
urutan. Kasus penggunaannya adalah peramalan pasar saham dan cuaca
peramalan. Berikut ini contohnya:
• Urutan masukan : 3,5,8,12
• Keluaran : 17
LSTM
3,5,8,12 Urutan 17
Prediksi pada Model
Memasukkan Keluaran (Nomor)
Klasifikasi Urutan
Klasifikasi urutan memprediksi label kelas untuk urutan yang diberikan. Penggunaannya
kasus adalah deteksi penipuan (yang menggunakan urutan transaksi sebagai input
untuk mengklasifikasikan/memprediksi apakah suatu akun telah diretas atau tidak) dan
klasifikasi siswa berdasarkan kinerja (urutan ujian
tanda selama enam bulan terakhir secara kronologis). Berikut ini contohnya:
• Urutan masukan : 2,4,6,8
• Keluaran : “Meningkat”
LSTM
2,4,6,8 “Meningkat”
Urutan
Model Klasifikasi
Memasukkan Keluaran (Label)
120
halaman 132
Bab 9 rNN dan LStM
Generasi Urutan
Pembuatan urutan adalah ketika Anda menghasilkan urutan output baru yang memiliki
properti yang sama dengan urutan input dalam korpus input. Penggunaannya
kasus adalah pembuatan teks (diberikan 100 baris blog, buat baris berikutnya
blog) dan pembuatan musik (diberikan contoh musik, hasilkan
karya musik baru). Berikut ini contohnya:
• Urutan masukan : [3, 5,8,12], [4,6,9,13]
• Keluaran : [5,7,10,14]
LSTM
Urutan
Genera pada Model
Memasukkan Keluaran (Urutan)
Prediksi Urutan ke Urutan

Prediksi urutan-ke-urutan adalah ketika Anda memprediksi urutan berikutnya
untuk urutan yang diberikan. Kasus penggunaannya adalah peringkasan dokumen dan
peramalan deret waktu multistep (memprediksi urutan angka).
Berikut ini contohnya:
• Urutan masukan : [3, 5,8,12,17]
• Keluaran : [23,30,38]
LSTM
Urutan ke
Model Urutan
Memasukkan Keluaran (urutan)
121
halaman 133
Bab 9 rNN dan LStM
Seperti disebutkan, LSTM digunakan untuk peramalan deret waktu dalam bisnis.
Mari kita lihat model LSTM. Asumsikan bahwa file CSV diberikan di mana
kolom pertama adalah stempel waktu dan kolom kedua adalah nilai. Bisa
mewakili data sensor (IoT).
Mengingat data deret waktu, Anda harus memprediksi nilai untuk masa depan.
Peramalan Deret Waktu dengan LSTM

Model
Berikut adalah contoh lengkap peramalan deret waktu dengan LSTM:
# LSTM sederhana untuk data deret waktu

impor matplotlib.pyplot sebagai plt
dari panda impor read_csv
impor matematika
dari keras.layers impor LSTM
dari sklearn.preprocessing impor StandardScaler
dari sklearn.metrics impor mean_squared_error
impor pylab
# mengonversi array nilai menjadi data deret waktu

def create_timeseries(seri, ts_lag=1):
dataX = []
dataY = []
n_baris = len(seri)-ts_lag
untuk saya dalam jangkauan (n_rows-1):
a = seri[i:(i+ts_lag), 0]
dataX.tambahkan(a)
dataY.append(seri[i + ts_lag, 0])
122
halaman 134
Bab 9 rNN dan LStM
X, Y = np.array(dataX), np.array(dataY)
kembali X, Y
# perbaiki benih acak untuk reproduktifitas
np.random.seed(230)
# memuat kumpulan data
dataframe = read_csv('sp500.csv', usecols=[0])
plt.plot(dataframe)
plt.tampilkan()
Angka 9-5 menunjukkan plot data.

Gambar 9-5. Plot datanya
Berikut beberapa kode lagi:
# Mengubah tipe data menjadi tipe float32

seri = dataframe.values.astype('float32')
# Normalisasi kumpulan data

penskala = StandardScaler()
seri = scaler.fit_transform(seri)
123
halaman 135
Bab 9 rNN dan LStM
# bagi set data menjadi set latih dan uji

train_size = int(len(seri) * 0.75)
test_size = len(seri) - train_size
kereta, tes = seri[0:kereta_ukuran,:], seri[kereta_
ukuran:len(seri),:]
# bentuk ulang rangkaian data kereta dan uji menjadi X=t dan Y=t+1
ts_lag = 1
trainX, trainY = create_timeseries(train, ts_lag)
testX, testY = create_timeseries(test, ts_lag)
# membentuk kembali data input menjadi [sampel, langkah waktu, fitur]

trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.
bentuk[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# Tentukan model LSTM

model = Berurutan()
model.add(LSTM(10, input_shape=(1, ts_lag)))
model.add(Padat(1))
model.compile(loss='mean_squared_logarithmic_error',
pengoptimal = 'adagrad')
#cocok dengan modelnya

model.fit(trainX, trainY, epochs=500, batch_size=30)
# membuat prediksi
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# skala ulang nilai prediksi

trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
124
halaman 136
Bab 9 rNN dan LStM
# menghitung kesalahan akar rata-rata kuadrat

trainScore = math.sqrt(mean_squared_error(trainY[0],
keretaPredict[:,0]))
print('Skor Kereta: %.2f RMSE' % (Skor kereta))
testScore = math.sqrt(mean_squared_error(testY[0],
tesPredict[:,0]))
print('Skor Tes: %.2f RMSE' % (Nilai Tes))
# plot dasar dan prediksi

pylab.plot(trainPredictPlot)
pylab.plot(testPredictPlot)
pylab.show()
Dalam Gambar 9-6, Anda dapat melihat plot waktu aktual versus perkiraan
seri. Bagian yang berwarna oranye adalah data pelatihan, bagian yang berwarna biru adalah ujian
data, dan bagian yang berwarna hijau adalah keluaran yang diprediksi.
Gambar 9-6. Plot deret waktu aktual versus yang diprediksi
Sejauh ini, kita telah mempelajari konsep RNN, LSTM, dan deret waktu
peramalan dengan model LSTM.
125
halaman 137
Bab 9 rNN dan LStM
LSTM telah digunakan dalam klasifikasi teks. Kami menggunakan LSTM (vanila LSTM
atau LSTM dua arah) untuk membangun pengklasifikasi teks. Pertama, korpus teks adalah
diubah menjadi angka dengan menggunakan penyisipan kata (semantik) seperti
word2vec atau sarung tangan. Kemudian, klasifikasi urutan dilakukan melalui LSTM.
Pendekatan ini menawarkan akurasi yang jauh lebih tinggi daripada kumpulan kata-kata biasa atau
tf-idf diikuti oleh pengklasifikasi ML seperti SVM, Random Forest. Di dalam
Bab 11, kita dapat melihat bagaimana LSTM dapat digunakan untuk pengklasifikasi.
126
halaman 138
BAB 10
Pidato ke Teks
dan sebaliknya
Dalam bab ini, Anda akan belajar tentang pentingnya pidato-ke-teks dan
konversi teks ke ucapan. Anda juga akan belajar tentang fungsi dan
komponen yang diperlukan untuk melakukan konversi jenis ini.
Secara khusus, saya akan membahas yang berikut:
• Mengapa Anda ingin mengonversi ucapan menjadi teks
• Ucapan sebagai data
• Fitur ucapan yang memetakan ucapan ke matriks
• Spektogram, yang memetakan ucapan ke gambar
• Membangun pengklasifikasi untuk pengenalan suara melalui

fitur mel-frequency cepstral coefficient (MFCC)
• Membangun pengklasifikasi untuk pengenalan suara melalui

spektogram
• Pendekatan sumber terbuka untuk pengenalan suara
• Penyedia layanan kognitif populer
• Masa depan pidato teks

https://doi.org/10.1007/978-1-4842-3516-4_10
halaman 139
BAB 10 PIDATO KE TEKS DAN SEBALIKNYA
Konversi Ucapan-ke-Teks
Konversi ucapan-ke-teks , dalam istilah awam, berarti aplikasi mengenali
kata-kata yang diucapkan oleh seseorang dan mengubah suara menjadi teks tertulis. Di sana
banyak alasan Anda ingin menggunakan konversi Ucapan-ke-Teks.
• Orang buta atau cacat fisik dapat mengontrol

perangkat yang berbeda hanya menggunakan suara.
• Anda dapat menyimpan catatan rapat dan acara lainnya dengan

mengubah percakapan lisan menjadi transkrip teks.
• Anda dapat mengonversi audio dalam file video dan audio ke

mendapatkan subtitle dari kata-kata yang diucapkan.
• Anda dapat menerjemahkan kata ke bahasa lain dengan

berbicara ke perangkat dalam satu bahasa dan mengonversi
text to speech dalam bahasa lain.
Pidato sebagai Data

Langkah pertama untuk membuat sistem pengenalan suara otomatis adalah:
dapatkan fitur - fiturnya . Dengan kata lain, Anda mengidentifikasi komponen audio
gelombang yang berguna untuk mengenali konten linguistik dan menghapus semua
fitur tidak berguna lainnya yang hanya suara latar belakang.
Pidato setiap orang disaring oleh bentuk saluran vokal mereka dan
juga oleh lidah dan gigi. Suara apa yang keluar tergantung pada ini
membentuk. Untuk mengidentifikasi fonem yang dihasilkan secara akurat, Anda perlu
untuk menentukan bentuk ini secara akurat. Bisa dibilang bentuk
saluran vokal memanifestasikan dirinya untuk membentuk amplop kekuatan waktu singkat
spektrum. Adalah tugas MFCC untuk mewakili amplop ini secara akurat.
Ucapan juga dapat direpresentasikan sebagai data dengan mengubahnya menjadi a
spektogram (Gambar 10-1).
128
halaman 140

Gambar 10-1. Ucapan sebagai data
Fitur Pidato: Pemetaan Pidato

ke Matriks
MFCC banyak digunakan dalam pengenalan suara dan pembicara otomatis.
Skala mel menghubungkan frekuensi yang dirasakan, atau nada , dari nada murni dengan
frekuensi terukur yang sebenarnya.
Anda dapat mengonversi audio dalam skala frekuensi ke skala mel menggunakan
rumus berikut:
M f( )= 1125 ln (1 + F / 700 )
Untuk mengubahnya kembali ke frekuensi, gunakan rumus berikut:
-(
Mm1
)= 700 (exp (M / 1125 ) - 1)
129
halaman 141
Berikut adalah fungsi untuk mengekstrak fitur MFCC dengan Python:
def mfcc (sinyal, sampel = 16000, winlen = 0,025, winstep = 0,01,

jumlah = 13, nfilt = 26, nfft = 512, frekuensi rendah = 0, frekuensi tinggi = Tidak ada,
preemph=0.97, ceplifter=22,appendEnergy=True)
Berikut adalah parameter yang digunakan:
• sinyal: Ini adalah sinyal yang Anda perlukan

menghitung fitur MFCC. Itu harus berupa
N*1 (membaca file WAV).
• samplerate: Ini adalah sample rate sinyal di mana

Anda bekerja.
• winlen: Ini adalah panjang jendela analisis dalam hitungan detik.

Secara default adalah 0,025 detik.
• winstep: Ini adalah langkah jendela yang berurutan. Secara default

adalah 0,01 detik.
• numcep: Ini adalah jumlah ceptrum yang fungsinya

harus kembali. Secara default adalah 13.
• nfilt: Ini adalah jumlah filter di bank filter. Oleh

defaultnya adalah 26.
• nfft: Ini adalah ukuran dari transformasi Fourier cepat (FFT).

Secara default adalah 512.
• frekuensi rendah: Ini adalah tepi pita terendah, dalam hertz. Oleh
defaultnya adalah 0.
• frekuensi tinggi: Ini adalah tepi pita tertinggi, dalam hertz. Oleh
defaultnya adalah sample rate dibagi 2.
130
halaman 142
• preemph: Ini menerapkan filter preemphasis dengan preemph

sebagai koefisien. 0 berarti tidak ada filter. Secara default adalah 0,97.
• ceplifter: Ini menerapkan lifter ke cepstral terakhir

koefisien. 0 berarti tidak ada pengangkat. Secara default adalah 22.
• appendEnergy: Koefisien cepstral ke-nol adalah

diganti dengan log energi bingkai total, jika disetel
untuk benar.
Fungsi ini mengembalikan array Numpy yang berisi fitur. Setiap baris
berisi satu vektor fitur.
Spektogram: Pemetaan Pidato

ke sebuah Gambar
Sebuah spektogram adalah representasi fotografi atau elektronik dari spektrum.
Idenya adalah untuk mengonversi file audio menjadi gambar dan meneruskan gambar
ke dalam model pembelajaran mendalam seperti CNN dan LSTM untuk analisis dan
klasifikasi.
Spektogram dihitung sebagai urutan FFT dari data berjendela
segmen. Format umum adalah grafik dengan dua dimensi geometris;
satu sumbu mewakili waktu, dan sumbu lain mewakili frekuensi. Ketiga
dimensi menggunakan warna atau ukuran titik untuk menunjukkan amplitudo a
frekuensi tertentu pada waktu tertentu. Spektogram biasanya dibuat
dalam salah satu dari dua cara. Mereka dapat didekati sebagai bank filter yang menghasilkan
dari serangkaian filter band-pass. Atau, dengan Python, ada fungsi langsung
yang memetakan audio ke spektogram.
131
halaman 143
Membangun Pengklasifikasi untuk Pengenalan Suara

Melalui Fitur MFCC
Untuk membuat pengklasifikasi untuk pengenalan suara, Anda harus memiliki python_
speech_features paket Python diinstal.
Anda dapat menggunakan perintah pip install python_speech_features untuk
menginstal paket ini.
Fungsi mfcc membuat matriks fitur untuk file audio. Untuk membangun sebuah
pengklasifikasi yang mengenali suara orang yang berbeda, Anda perlu mengumpulkan
data pidato mereka dalam format WAV. Kemudian Anda mengonversi semua file audio
menjadi matriks menggunakan fungsi mfcc. Kode untuk mengekstrak fitur dari
file WAV ditampilkan di sini:
Jika Anda menjalankan kode sebelumnya, Anda akan mendapatkan output dalam bentuk berikut:
[[ 7.66608682 7.04137131 7.30715423 ..., 9.43362359 9.11932984

9.93454603]
[ 4.9474559 4.97057377 6.90352236 ..., 8.6771281 8.86454547
9.7975147 ]
[ 7.4795622 6.63821063 5.98854983 ..., 8.78622734 8.805521
983712966]
...,
[ 7.8886269 6.57456605 6.47895433 ..., 8.62870034 8.79965464
9.67997298]
132
halaman 144
Bab 10 Bicara ke teks dan Wakil VerSa
[ 5.73028657 4.87985847 6.64977329 ..., 8.64089442 8.62887745

9.90470194]
[ 8.8449656 6.67098127 7.09752316 ..., 8.84914694 8.97807983
9.45123015]]
Di sini, setiap baris mewakili satu vektor fitur.

Kumpulkan sebanyak mungkin rekaman suara seseorang dan tambahkan
matriks fitur dari setiap file audio dalam matriks ini.
Ini akan bertindak sebagai kumpulan data pelatihan Anda.
Ulangi langkah yang sama dengan semua kelas lainnya.
Setelah kumpulan data disiapkan, Anda dapat memasukkan data ini ke kedalaman apa pun
model pembelajaran (yang digunakan untuk klasifikasi) untuk mengklasifikasikan suara
orang yang berbeda.
Catatan untuk melihat kode lengkap pengklasifikasi menggunakan fitur MFCC, Anda
dapat mengunjungi www.navinmanaswi.com/SpeechRecognizer.
Membangun Pengklasifikasi untuk Pengenalan Suara

Melalui Spektogram
Menggunakan pendekatan spektogram mengubah semua file audio menjadi gambar
(Gambar 10-2), jadi yang harus Anda lakukan adalah mengonversi semua file suara di
melatih data menjadi gambar dan memasukkan gambar tersebut ke model pembelajaran yang mendalam
seperti yang Anda lakukan di CNN.
133
halaman 145
Gambar 10-2. Spektogram sampel pidato
Berikut adalah kode Python untuk mengonversi file audio menjadi spektogram:
134
halaman 146
Pendekatan Sumber Terbuka

Ada paket open source yang tersedia untuk Python yang berfungsi
konversi ucapan-ke-teks dan teks-ke-ucapan.
Berikut adalah beberapa API konversi ucapan-ke-teks open source:
• PocketSphinx
• Pidato Google
• Ucapan Google Cloud
• Wit.ai
• Houndify
• IBM Speech to Text API
• Pidato Bing Microsoft
Setelah menggunakan semua ini, saya dapat mengatakan bahwa mereka bekerja dengan cukup baik; NS
Aksen Amerika sangat jelas.
Jika Anda tertarik untuk mengevaluasi keakuratan konversi, Anda
membutuhkan satu metrik: tingkat kesalahan kata (WER).
Di bagian selanjutnya, saya akan membahas masing-masing API yang disebutkan sebelumnya.
Contoh Menggunakan Setiap API

Mari kita lihat setiap API.
Menggunakan PocketSphinx
PocketSphinx adalah API open source yang digunakan untuk konversi ucapan-ke-teks. Dia
adalah mesin pengenalan suara yang ringan, khusus disetel untuk perangkat genggam
dan perangkat seluler, meskipun berfungsi sama baiknya di desktop. Secara sederhana
gunakan perintah pip install PocketSphinx untuk menginstal paket.
135
halaman 147
impor speech_recognition sebagai sr

dari jalur impor os
AUDIO_FILE = "MyAudioFile.wav"
r = sr.Pengenal()
dengan sr.AudioFile(AUDIO_FILE) sebagai sumber:
audio = r.record(sumber)
mencoba:
print("Sphinx mengira Anda mengatakan " + r.recognize_sphinx(audio))
kecuali sr.UnknownValueError:
print("Sphinx tidak mengerti suara")
kecuali sr.RequestError sebagai e:
print("Kesalahan Sphinx; {0}".format(e))
================================================== ===============
Menggunakan Google Speech API

Google menyediakan Speech API sendiri yang dapat diimplementasikan dengan Python
kode dan dapat digunakan untuk membuat aplikasi yang berbeda.
# mengenali ucapan menggunakan Google Speech Recognition

mencoba:
print("Google Speech Recognition mengira Anda mengatakan " +
r.recognize_google(audio))
print("Google Speech Recognition tidak dapat memahami audio")
print("Tidak dapat meminta hasil dari Google Speech
Layanan pengenalan;{0}".format(e))
136
halaman 148
Menggunakan Google Cloud Speech API

Anda juga dapat menggunakan Google Cloud Speech API untuk konversi. Membuat
akun di Google Cloud dan salin kredensialnya.
GOOGLE_CLOUD_SPEECH_CREDENTIALS = r"MASUKKAN ISI

FILE KREDENSIAL JSON GOOGLE CLOUD SPEECH DI SINI" coba:
print("Google Cloud Speech mengira Anda mengatakan " +
r.recognize_google_cloud(audio, kredensial_json=GOOGLE_
CLOUD_SPEECH_CREDENTIALS))
print("Google Cloud Speech tidak dapat memahami audio")
print("Tidak dapat meminta hasil dari Google Cloud Speech
melayani; {0}".format(e))
Menggunakan API Wit.ai

Wit.ai API memungkinkan Anda membuat konverter ucapan-ke-teks. Kamu butuh
buat akun dan kemudian buat proyek. Salin kunci Wit.ai Anda dan mulai
pengkodean.
#kenali ucapan menggunakan Wit.ai

WIT_AI_KEY = "MASUKKAN KUNCI API WIT.AI DI SINI" # Kunci Wit.ai adalah
string alfanumerik huruf besar 32 karakter
mencoba:
print("Wit.ai mengira Anda mengatakan " + r.recognize_wit(audio,
kunci=WIT_AI_KEY))
print("Wit.ai tidak mengerti audio")
print("Tidak dapat meminta hasil dari layanan Wit.ai; {0}".
format))
137
halaman 149
Menggunakan API Houndify

Mirip dengan API sebelumnya, Anda perlu membuat akun di Houndify
dan dapatkan ID klien dan kunci Anda. Ini memungkinkan Anda membuat aplikasi yang
merespon suara.
# mengenali ucapan menggunakan Houndify

HOUNDIFY_CLIENT_ID = "MASUKKAN ID KLIEN HOUNDIFY DI SINI"
# ID klien Houndify adalah string yang disandikan Base64
HOUNDIFY_CLIENT_KEY = "MASUKKAN KUNCI KLIEN HOUNDIFY DI SINI"
# Kunci klien Houndify adalah string yang disandikan Base64
mencoba:
print("Houndify mengira Anda mengatakan " + r.recognize_
houndify(audio, client_id=HOUNDIFY_CLIENT_ID, client_
kunci=HOUNDIFY_CLIENT_KEY))
print("Houndify tidak mengerti audio")
print("Tidak dapat meminta hasil dari layanan Houndify;
{0}".format(e))
Menggunakan IBM Speech to Text API

IBM Speech to Text API memungkinkan Anda untuk menambahkan pengenalan suara IBM
kemampuan untuk aplikasi Anda. Masuk ke cloud IBM dan mulai
proyek untuk mendapatkan nama pengguna dan kata sandi IBM.
# IBM Pidato ke Teks

# mengenali ucapan menggunakan IBM Speech to Text
IBM_USERNAME = "INSERT IBM SPEECH TO TEXT USERNAME HERE" # IBM
Nama pengguna Speech to Text adalah string dalam bentuk XXXXXXX-XXXX-
XXXX-XXXX-XXXXXXXXXXXX
138
halaman 150
IBM_PASSWORD = "INSERT IBM SPEECH TO TEXT PASSWORD HERE" # IBM

Kata sandi Speech to Text adalah string alfanumerik huruf besar-kecil
mencoba:
print("IBM Speech to Text mengira Anda mengatakan " + r.recognize_
ibm(audio, nama pengguna=IBM_USERNAME, sandi=IBM_PASSWORD))
print("IBM Speech to Text tidak dapat memahami audio")
print("Tidak dapat meminta hasil dari IBM Speech to Text
melayani; {0}".format(e))
Menggunakan API Pengenalan Suara Bing

API ini mengenali audio yang berasal dari mikrofon secara real time. Membuat
akun di Bing.com dan dapatkan kunci API Pengenalan Suara Bing.
# mengenali ucapan menggunakan Microsoft Bing Voice Recognition

BING_KEY = "MASUKKAN BING API KEY DI SINI" # Microsoft Bing Voice
Kunci API Pengenalan adalah heksadesimal huruf kecil 32 karakter
senar
mencoba:
print("Pengenalan Suara Microsoft Bing mengira Anda mengatakan " +
r.recognize_bing(audio, kunci=BING_KEY))
print("Pengenalan Suara Microsoft Bing tidak bisa
mengerti audio")
print("Tidak dapat meminta hasil dari Microsoft Bing Voice
Layanan pengakuan; {0}".format(e))
Setelah Anda mengubah pidato menjadi teks, Anda tidak dapat mengharapkan
akurasi 100 persen. Untuk mengukur akurasi, Anda dapat menggunakan WER.
139
halaman 151
Konversi Text-to-Speech
Bagian bab ini berfokus pada konversi teks tertulis ke file audio.
Menggunakan pyttsx
Menggunakan paket Python yang disebut pyttsx, Anda dapat mengonversi teks menjadi audio.
Lakukan pip install pyttsx. Jika Anda menggunakan python 3.6 maka lakukan
pip3 instal pyttsx3.
impor pyttsx
mesin = pyttsx.init()
engine.say("Pesan Anda")
mesin.runDanTunggu()
Menggunakan SAPI
Anda juga dapat menggunakan SAPI untuk melakukan konversi text-to-speech dengan Python.
dari konstanta impor win32com.client, Dispatch

Msg = "Hai ini ujian"
speaker = Dispatch("SAPI.SpVoice") #Buat Objek SAPI SpVoice
pembicara.Berbicara(Msg) #Proses TTS
del pembicara
Menggunakan SpeechLib
Anda dapat mengambil input dari file teks dan mengubahnya menjadi audio menggunakan
SpeechLib, seperti yang ditunjukkan di sini:
dari comtypes.client impor CreateObject

mesin = CreateObject("SAPI.SpVoice")
140
halaman 152
aliran = CreateObject("SAPI.SpFileStream")
dari comtypes.gen impor SpeechLib
infile = "SHIVA.txt"
outfile = "SHIVA-audio.wav"
stream.Open(outfile, SpeechLib.SSFMCreateForWrite)
engine.AudioOutputStream = aliran
f = buka(infile, 'r')
theText = f.read()
f.tutup()
engine.speak(teks)
aliran.Tutup()
Sering kali, Anda harus mengedit audio sehingga Anda dapat menghapus suara
dari berkas audio. Bagian selanjutnya menunjukkan caranya.
Kode Pemotongan Audio

Buat file CSV audio yang berisi nilai yang dipisahkan koma dari
detail audio dan lakukan hal berikut menggunakan Python:
gelombang impor
sistem impor
impor os
impor csv
origAudio = wave.open('Howard.wav', 'r') #ubah jalur
frameRate = origAudio.getframerate()
nChannels = origAudio.getnchannels()
sampWidth = origAudio.getsampwidth()
nFrames = origAudio.getnframes()
nama file = 'result1.csv' #ubah jalur
141
halaman 153
contohFile = buka(nama file)

contohPembaca = csv.pembaca (contohFile)
contohData = daftar(pembaca contoh)
hitung = 0
untuk data dalam contohData:

#untuk pilihan dalam data:
print('Pilihan', data[4], data[5])
hitung += 1
jika data[4] == 'startTime' dan data[5] == 'endTime':
print('Waktu mulai')
lain:
mulai = float(data[4])
akhir = float(data[5])
origAudio.setpos(mulai*frameRate)
chunkData = origAudio.readframes(int((end-
mulai)*frameRate))
outputFilePath = 'C:/Users/Navin/outputFile{0}.wav'.
format(hitungan) # ubah jalur
chunkAudio = wave.open(outputFilePath, 'w')
chunkAudio.setnchannels(nChannels)
chunkAudio.setsampwidth(sampWidth)
chunkAudio.setframerate(frameRate)
chunkAudio.writeframes(chunkData)
potonganAudio.close()
Penyedia Layanan Kognitif

Mari kita lihat beberapa penyedia layanan kognitif yang membantu berbicara
pengolahan.
142
halaman 154
Microsoft Azure
Microsoft Azure menyediakan yang berikut ini:
• Layanan Ucapan Khusus : Ini mengatasi ucapan

hambatan pengenalan seperti gaya berbicara, kosa kata,
dan kebisingan latar belakang.
• API Pidato Penerjemah : Ini memungkinkan pidato waktu nyata

terjemahan.
• API Identifikasi Pembicara : Ini dapat mengidentifikasi

pembicara berdasarkan sampel pidato masing-masing pembicara di
data audio yang diberikan.
• Bing Speech API : Ini mengubah audio menjadi teks,

memahami maksud, dan mengubah teks kembali menjadi ucapan
untuk respons alami.
Layanan Kognitif Amazon

Amazon Cognitive Services menyediakan Amazon Polly, layanan yang
mengubah teks menjadi ucapan. Amazon Polly memungkinkan Anda membuat aplikasi yang
bicara, memungkinkan Anda untuk membangun kategori yang sepenuhnya baru dari kemampuan bicara
produk.
• 47 suara dan 24 bahasa dapat digunakan, dan seorang India

Pilihan bahasa Inggris disediakan.
• Nada seperti berbisik, marah, dan sebagainya, bisa

ditambahkan ke bagian tertentu dari pidato menggunakan Amazon
efek.
143
halaman 155
• Anda dapat menginstruksikan sistem cara mengucapkan a

frase atau kata tertentu dengan cara yang berbeda. Untuk
contoh, "W3C" diucapkan sebagai World Wide Web
Konsorsium, tetapi Anda dapat mengubahnya untuk diucapkan
singkatan saja. Anda juga dapat memberikan teks input di
format SSML.
Layanan IBM Watson

Ada dua layanan dari IBM Watson.
• Speech to text : Bahasa Inggris AS, Spanyol, dan Jepang
• Text to speech : Bahasa Inggris AS, Bahasa Inggris UK, Bahasa Spanyol,
Prancis, Italia, dan Jerman
Masa Depan Analisis Ucapan

Teknologi pengenalan ucapan telah membuat kemajuan besar. Setiap
tahun, itu sekitar 10 sampai 15 persen lebih akurat dari tahun sebelumnya. Di dalam
masa depan, ini akan menyediakan antarmuka paling interaktif untuk komputer.
Ada banyak aplikasi yang akan segera Anda saksikan di
pasar, termasuk buku interaktif, kontrol robot, dan mengemudi sendiri
antarmuka mobil. Data ucapan menawarkan beberapa kemungkinan baru yang menarik karena
itu adalah masa depan industri. Kecerdasan bicara memungkinkan orang untuk
mengirim pesan, menerima atau memberi perintah, menyampaikan keluhan, dan melakukan pekerjaan apa pun di mana
mereka biasa mengetik secara manual. Ini menawarkan pengalaman pelanggan yang luar biasa dan
mungkin itu sebabnya semua departemen dan bisnis yang berhadapan dengan pelanggan cenderung
untuk menggunakan aplikasi pidato sangat berat. Saya bisa melihat masa depan yang hebat untuk pidato
pengembang aplikasi.
144
halaman 156
BAB 11
Mengembangkan Chatbot
Sistem kecerdasan buatan yang bertindak sebagai antarmuka untuk manusia dan
interaksi mesin melalui teks atau suara disebut chatbots .
Interaksi dengan chatbots mungkin langsung atau
kompleks. Contoh interaksi langsung bisa bertanya
tentang laporan berita terbaru. Interaksi bisa menjadi lebih kompleks
ketika mereka tentang pemecahan masalah dengan, katakanlah, Android Anda
telepon. Istilah chatbots telah mendapatkan popularitas luar biasa di masa lalu
tahun dan telah berkembang menjadi platform yang paling disukai untuk interaksi pengguna
dan keterlibatan. Sebuah bot , bentuk lanjutan dari ChatBot sebuah, membantu mengotomatisasi
tugas "yang dilakukan pengguna".
Bab tentang chatbot ini akan berfungsi sebagai panduan menyeluruh untuk
apa, bagaimana, di mana, kapan, dan mengapa chatbots!
Secara khusus, saya akan membahas yang berikut:
• Mengapa Anda ingin menggunakan chatbots
• Desain dan fungsi chatbot
• Langkah-langkah membuat chatbot
• Pengembangan chatbot menggunakan API
• Praktik terbaik chatbot

https://doi.org/10.1007/978-1-4842-3516-4_11
halaman 157
BAB 11 MENGEMBANGKAN CHATBOT
Mengapa Chatbot?
Penting bagi chatbot untuk memahami informasi apa yang dimiliki pengguna
mencari, disebut niat . Misalkan pengguna ingin tahu yang terdekat
restoran vegetarian; pengguna dapat mengajukan pertanyaan itu dalam banyak kemungkinan
cara. Chatbot (khususnya pengklasifikasi maksud di dalam chatbot)
harus dapat memahami maksudnya karena pengguna ingin mendapatkan
jawaban benar. Padahal, untuk memberikan jawaban yang benar, chatbot harus bisa
memahami konteks, maksud, entitas, dan sentimen. Chatbot harus
bahkan memperhitungkan apa pun yang dibahas dalam sesi. Misalnya,
pengguna mungkin bertanya “Berapa harga ayam biryani disana?”
Meskipun pengguna telah meminta harga, mesin obrolan dapat salah paham
dan asumsikan pengguna sedang mencari restoran. Jadi, sebagai tanggapan,
chatbot dapat memberikan nama restoran.
Desain dan Fungsi Chatbots

Chatbot merangsang percakapan cerdas dengan manusia melalui
penerapan AI.
Antarmuka tempat percakapan berlangsung difasilitasi melalui
baik teks lisan maupun tulisan. Facebook Messenger, Slack, dan Telegram
memanfaatkan platform perpesanan chatbot. Mereka melayani banyak tujuan,
termasuk memesan produk secara online, berinvestasi dan mengelola keuangan,
dan seterusnya. Aspek penting dari chatbots adalah mereka membuat kontekstual
percakapan kemungkinan. Chatbots berkomunikasi dengan pengguna dengan cara
mirip dengan bagaimana manusia berkomunikasi dalam kehidupan sehari-hari mereka. Meskipun itu
mungkin bagi chatbot untuk berkomunikasi secara kontekstual, mereka masih memiliki jalan panjang untuk
pergi dalam hal berkomunikasi secara kontekstual dengan segala sesuatu dan apa saja.
Tetapi antarmuka obrolan menggunakan bahasa untuk menghubungkan mesin
kepada pria itu, membantu orang menyelesaikan sesuatu dengan cara yang nyaman dengan
memberikan informasi secara kontekstual.
146
halaman 158
Selain itu, chatbots mendefinisikan ulang cara bisnis saat ini

diadakan. Dari menjangkau konsumen hingga menyambut mereka untuk
ekosistem bisnis untuk memberikan informasi kepada konsumen
tentang berbagai produk dan fitur-fiturnya, chatbots membantu dengan itu semua.
Mereka muncul sebagai cara paling nyaman untuk berurusan dengan konsumen
tepat waktu dan memuaskan.
Langkah-Langkah Membangun Chatbot

Chatbot dibuat untuk berkomunikasi dengan pengguna dan memberi mereka perasaan bahwa
mereka berkomunikasi dengan manusia dan bukan bot. Tetapi ketika pengguna
memberikan masukan, biasanya mereka tidak memberikan masukan dengan cara yang benar.
Dengan kata lain, mereka mungkin memasukkan tanda baca yang tidak perlu, atau di sana
mungkin cara yang berbeda untuk mengajukan pertanyaan yang sama.
Misalnya, untuk “Restoran di dekat saya?” pengguna dapat memasukkan
“Restoran di sampingku?” atau “Temukan restoran terdekat”.
Oleh karena itu, Anda perlu melakukan preprocess data agar mesin chatbot
dapat dengan mudah memahaminya. Angka 11-1 menunjukkan proses, yang terperinci
di bagian berikut.
Gambar 11-1. Bagan alur untuk menunjukkan bagaimana mesin chatbot memproses dan
input string dan memberikan jawaban yang valid.
147
halaman 159
Teks dan Pesan Prapemrosesan

Prapemrosesan teks dan pesan mencakup beberapa langkah, dibahas selanjutnya.
Tokenisasi
Memotong kalimat menjadi kata-kata tunggal (disebut token ) disebut
tokenisasi . Dalam Python, umumnya string diberi token dan disimpan dalam daftar.
Misalnya, kalimat "Kecerdasan buatan"

adalah tentang menerapkan matematika” menjadi
mengikuti:
["Buatan", "kecerdasan", "adalah", "semua", "tentang",
"menerapkan", "matematika"]
Berikut adalah contoh kodenya:
dari nltk.tokenize impor TreebankWordTokenizer

l = "Kecerdasan buatan adalah tentang menerapkan matematika"
token = TreebankWordTokenizer().tokenize(l)
cetak (tanda)
Menghapus Tanda Baca

Anda juga dapat menghapus tanda baca yang tidak perlu dalam kalimat.
Misalnya, kalimat “Bisakah saya mendapatkan daftarnya?

restoran, yang memberikan pengiriman ke rumah.” menjadi
pengikut:
“Bisakah saya mendapatkan daftar restoran yang memberi rumah

pengiriman."
148
halaman 160

dari nltk.corpus mengimpor stopwords
l = "Kecerdasan buatan adalah tentang menerapkan
matematika!"
keluaran = []
output = [k untuk k dalam token jika k.isalpha()]
cetak (keluaran)
Menghapus Stop Words

Stopwords adalah kata -kata yang ada dalam kalimat yang tidak membuat banyak
perbedaan jika dihapus. Meskipun format kalimatnya berubah, ini
banyak membantu dalam pemahaman bahasa alami (NLU).
Misalnya, kalimat "Kecerdasan buatan"

dapat mengubah gaya hidup masyarakat.” menjadi
berikut setelah menghapus kata berhenti:
"Kecerdasan buatan mengubah gaya hidup orang."

dari nltk.corpus mengimpor stopwords
l = "Kecerdasan buatan adalah tentang menerapkan matematika"
stop_words = set(stopwords.words('english'))
keluaran= []
untuk k dalam token:
jika k tidak ada di stop_words:
keluaran.tambahkan(k)
cetak (keluaran)
149
halaman 161
Kata-kata mana yang dianggap sebagai stop word bisa bermacam-macam. Ada
beberapa set kata henti yang telah ditentukan sebelumnya disediakan oleh Natural Language Toolkit
(NLTK), Google, dan lainnya.
Pengakuan Entitas Bernama

Pengenalan entitas bernama (NER), juga dikenal sebagai identifikasi entitas , adalah
tugas mengklasifikasikan entitas dalam teks ke dalam kelas yang telah ditentukan seperti nama
negara, nama orang, dan sebagainya. Anda juga dapat menentukan
kelas sendiri.
Misalnya, menerapkan NER pada kalimat “Hari ini

Pertandingan kriket India vs Australia sangat fantastis.” memberi
Anda output berikut:
[Hari ini]Waktu [India] Negara vs Negara [Australia]

Pertandingan [kriket] sangat fantastis.
Untuk menjalankan kode NER, Anda perlu mengunduh dan mengimpor

paket yang diperlukan, seperti yang disebutkan dalam kode berikut.
Menggunakan Stanford NER

Untuk menjalankan kode, unduh english.all.3class.dissim.crf.ser.gz
dan file stanford-ner.jar.
dari nltk.tag impor StanfordNERTagger

dari nltk.tokenize impor word_tokenize
StanfordNERTagger("stanford-ner/classifiers/english.all.3class.
distsim.crf.ser.gz",
"stanford-ner/stanford-ner.jar")
text = "Ron adalah pendiri Ron Institute di New york"

teks = word_tokenize(teks)
ner_tags = ner_tagger.tag(teks)
cetak(ner_tags)
150
halaman 162
Menggunakan MITIE NER (Terlatih)

Unduh file ner_model.dat dari MITIE untuk menjalankan kode.
dari mitie.mitie impor *

dari nltk.tokenize impor word_tokenize
print("memuat model NER...")

ner = bernama_entity_extractor("mitie/MITIE-model/english/
ner_model.dat".encode("utf8"))
text = "Ron adalah pendiri Ron Institute di New york".

enkode("utf-8")
teks = word_tokenize(teks)
ner_tags = ner.extract_entities(teks)
print("\nEntitas ditemukan:", ner_tags)
untuk e di ner_tags:
rentang = e[0]
tanda = e[1]
entity_text = " ".join(text[i].decode() untuk i dalam jangkauan)
print( str(tag) + " : " + entity_text)
Menggunakan MITIE NER (Self-Trained)

Unduh file total_word_feature_extractor.dat dari MITIE
( https://github.com/mit-nlp/MITIE) untuk menjalankan kode.
dari mitie.mitie impor *
sample = ner_training_instance([b"Ron", b"was", b"the", b"founder",

b"dari", b"Ron", b"Lembaga", b"di", b"Baru", b"York", b"."])
sample.add_entity(range(0, 1), "person".encode("utf-8"))

sample.add_entity(rentang(5, 7), "organisasi".encode("utf-8"))
sample.add_entity(range(8, 10), "Location".encode("utf-8"))
151
halaman 163
pelatih = ner_trainer("mitie/MITIE-models/english/total_word_
feature_extractor.dat".encode("utf-8"))
pelatih.add(contoh)
ner = pelatih.train()
token = [b"John", b"was", b"the", b"founder", b"of", b"John",

b"Universitas", b"."]
entitas = ner.extract_entities(token)
print ("\nEntitas ditemukan:", entitas)
untuk e dalam entitas:
rentang = e[0]
tanda = e[1]
entity_text = " ".join(str(token[i]) untuk i dalam jangkauan)
print(" " + str(tag) + ": " + teks_entitas)
Klasifikasi Niat
Klasifikasi maksud adalah langkah dalam NLU di mana Anda mencoba memahami apa
diinginkan pengguna. Berikut adalah dua contoh input ke chatbot untuk menemukan tempat
di dekat sini:
• “Saya perlu membeli bahan makanan.” : Tujuannya adalah untuk mencari

toko kelontong di dekatnya.
• “Saya ingin makan makanan vegetarian.” : Tujuannya adalah untuk melihat

untuk restoran terdekat, idealnya yang vegetarian.
Pada dasarnya, Anda perlu memahami apa yang dicari pengguna dan
dengan demikian mengklasifikasikan permintaan ke dalam kategori niat tertentu (Gambar 11- 2 ).
152
halaman 164
Gambar 11-2. Aliran umum klasifikasi maksud, dari kalimat ke

vektor ke model
Untuk melakukan ini, Anda perlu melatih model untuk mengklasifikasikan permintaan ke dalam maksud
menggunakan algoritma, dari kalimat ke vektor ke model.
Penyematan Kata
Penyematan kata adalah teknik mengubah teks menjadi angka. Dia
sulit untuk menerapkan algoritma apapun dalam teks. Oleh karena itu, Anda harus mengubahnya menjadi
angka.
Berikut ini adalah berbagai jenis teknik penyisipan kata.
153
halaman 165
Hitung Vektor
Misalkan Anda memiliki tiga dokumen (D1, D2, dan D3) dan ada N
kata-kata unik dalam kelompok dokumen. Anda membuat matriks (D×N),
disebut C, yang dikenal sebagai vektor hitungan . Setiap entri matriks adalah
frekuensi kata unik dalam dokumen itu.
Mari kita lihat ini menggunakan contoh.
D1 : Pooja sangat malas.
D2 : Tapi dia cerdas.
D3 : Dia jarang masuk kelas.
Di sini, D=3 dan N=12.

Kata - kata uniknya susah , malas , Tapi , untuk , Pooja , dia , cerdas ,
datang , sangat , kelas , dan ini .
Oleh karena itu, vektor hitungan, C, adalah sebagai berikut:
Hampir tidak pemalas Tapi bagi Pooja dia cerdas datang sangat berkelas adalah
H1 0 1 0 01 0 0 0 1 0 1
D2 0 0 1 00 1 1 0 0 0 1
D3 1 0 0 10 1 0 1 0 1 0
Term Frequency-Inverse Document Frequency (TF-IDF)
Untuk teknik ini, Anda memberi setiap kata dalam kalimat sebuah angka
tergantung pada berapa kali kata itu muncul dalam kalimat itu dan
juga tergantung pada dokumen. Kata-kata yang muncul berkali-kali dalam a
kalimat dan tidak terlalu sering dalam sebuah dokumen akan memiliki nilai yang tinggi.
154
halaman 166
Misalnya, pertimbangkan satu set kalimat:
• "Saya anak lelaki."
• "Saya seorang gadis."
• "Kamu tinggal di mana?"
TF-IDF mengubah set fitur untuk kalimat sebelumnya, sebagai

ditampilkan di sini:
NS Anak laki-laki
Gadis Di mana melakukanAnda hidup
1. 0,60 0,80 0 0 0 0 0
2. 0,60 0 0,80 0 0 0 0
3. 0 0 0 0,5 0,5 0,5 0,5
Anda dapat mengimpor paket TFIDF dan menggunakannya untuk membuat tabel ini.
Sekarang mari kita lihat beberapa contoh kode. Anda dapat menggunakan pengklasifikasi vektor dukungan
pada fitur TF-IDF yang diubah dari string permintaan.
#impor paket yang diperlukan

impor panda sebagai pd
dari sampel impor acak
dari sklearn.preprocessing impor LabelEncoder
dari sklearn.feature_extraction.text impor TfidfVectorizer
dari sklearn.svm impor SVC
dari sklearn.model_selection impor train_test_split
dari sklearn.metrics impor f1_score, akurasi_score
# baca file csv
data = pd.read_csv("intent1.csv")
cetak(data.contoh(6))
155
halaman 167
Bab 11 Mengembangkan Chatbot
Sebelum melanjutkan dengan kode, berikut adalah contoh kumpulan data:
Deskripsi (Pesan) intent_label (Target)
restoran non-sayuran yang bagus di dekat saya?

0
saya mencari rumah sakit 1
rumah sakit yang bagus untuk operasi jantung

1
sekolah internasional untuk anak-anak 2
restoran non-sayuran di sekitar saya 0
sekolah untuk anak kecil 2
Dalam contoh ini, ini adalah nilai yang akan digunakan:
• 0 berarti mencari restoran.
• 1 berarti mencari rumah sakit.
• 2 berarti mencari sekolah.
Sekarang mari kita bekerja pada kumpulan data.
# pisahkan dataset menjadi latih dan uji.

X_train, X_test, Y_train, Y_test = train_test_split(data
["Deskripsi"], data["label_maksud"], ukuran_tes=3)
print(X_train.shape, X_test.shape, Y_train.shape, Y_test.shape)
# membuat vektor input menggunakan nilai tfidf.

tfidf = TfidfVectorizer()
tfidf = tfidf.fit(X_train)
X_train = tfidf.transform(X_train)
X_test = tfidf.transform(X_test)
# penyandian label untuk berbagai kategori maksud

le = LabelEncoder().fit(Y_train)
Y_train = le.transform(Y_train)
Y_test = le.transform(Y_test)
156
halaman 168
# model lain seperti GBM, Hutan Acak juga dapat digunakan

model = SVC()
model = model.fit(X_train, Y_train)
p = model.predict(X_test)
# hitung f1_score. rata-rata="mikro" karena kami ingin
menghitung skor untuk multiclass.
# Setiap instance (bukan kelas (cari rata-rata makro))
berkontribusi sama terhadap penilaian.
print("f1_score:", f1_score( Y_test, p, rata-rata="mikro"))
print("skor_akurasi:",skor_akurasi(uji_y, p))
Word2Vec
Ada berbagai metode untuk mendapatkan vektor kata untuk sebuah kalimat, tetapi
teori utama di balik semua teknik adalah memberi kata-kata yang mirip dengan yang serupa
representasi vektor. Jadi, kata-kata seperti laki - laki dan laki - laki dan perempuan akan memiliki kesamaan
vektor. Panjang setiap vektor dapat diatur. Contoh Word2vec
teknik termasuk GloVe dan CBOW (n-gram dengan atau tanpa skip gram).
Anda dapat menggunakan Word2vec dengan melatihnya untuk kumpulan data Anda sendiri (jika Anda memiliki
cukup data untuk masalah), atau Anda dapat menggunakan data yang telah dilatih sebelumnya. Word2vec
tersedia di Internet. Model yang telah dilatih sebelumnya telah dilatih pada skala besar
dokumen seperti data Wikipedia, tweet, dan lain-lain, dan semuanya hampir
selalu baik untuk masalah.
Contoh beberapa teknik yang dapat Anda gunakan untuk melatih niat Anda
classifier adalah dengan menggunakan 1D-CNN pada vektor kata dari kata-kata dalam sebuah kalimat,
ditambahkan dalam daftar untuk setiap kalimat.
# impor paket yang diperlukan

dari gensim.models mengimpor Word2Vec
impor panda sebagai pd
dari keras.preprocessing.text import Tokenizer
157
halaman 169
dari keras.preprocessing.sequence import pad_sequences

dari keras.utils.np_utils impor ke_kategorikal
dari keras.layers impor Padat, Masukan, Ratakan
dari keras.layers impor Conv1D, MaxPooling1D, Embedding, Dropout
dari keras.models import Model
dari sklearn.preprocessing impor LabelEncoder

dari sklearn.model_selection impor train_test_split
dari sklearn.metrics impor f1_score, akurasi_score
# membaca data
data = pd.read_csv("intent1.csv")
# pisahkan data menjadi tes dan latih

X_train, X_test, Y_train, Y_test = train_test_split(data
["Deskripsi"], data["label_maksud"], ukuran_tes=6)
# penyandian label untuk berbagai kategori maksud

le = LabelEncoder().fit(Y_train)
Y_train = le.transform(Y_train)
Y_test = le.transform(Y_test)
# dapatkan vektor_kata untuk kata-kata dalam set pelatihan

X_train = [dikirim untuk dikirim di X_train]
X_test = [dikirim untuk dikirim di X_test]
# secara default genism.Word2Vec menggunakan CBOW, untuk melatih kata vecs.
Kami juga dapat menggunakan skipgram dengan itu
# dengan mengatur atribut "sg" ke jumlah lompatan yang kita inginkan.
# CBOW dan Lewati gram untuk kalimat "Hai Ron bagaimana kabarmu
hari?" menjadi:
# Sekantong kata terus menerus: 3-gram {"Hai Ron bagaimana", "Ron apa kabar",
"bagaimana kabarmu" ...}
# Lewati-gram 1-lewati 3-gram: {"Hai Ron bagaimana", "Hai Ron dulu", "Hai
bagaimana", "Ron bagaimana
# milikmu", ...}
158
halaman 170
# Lihat caranya: "Hai Ron dulu" melompati "bagaimana".

# Lewati-gram 2-lewati 3-gram: {"Hai Ron bagaimana", "Hai Ron dulu", "Hai
Ron kamu", "Hai tadi
# milikmu", ...}
# Lihat caranya: "Hai Ron Anda" melompati "bagaimana kabarnya".
# Itulah pengertian umum dari CBOW dan skip gram.
word_vecs = Word2Vec(X_train)
print("Vektor kata dilatih")
# pangkas setiap kalimat hingga maksimal 20 kata.

max_sent_len = 20
# tokenisasi string input

tokenizer = Tokenizer()
tokenizer.fit_on_texts(X_train)
urutan = tokenizer.texts_to_sequences(X_train)
sequences_test = tokenizer.texts_to_sequences(X_test)
word_index = tokenizer.word_index
vocab_size = len(indeks_kata)
# kalimat dengan kurang dari 20 kata, akan diisi dengan nol

jadilah panjangnya 20
# kalimat dengan lebih dari 20 kata, akan dipangkas menjadi 20.
x = pad_sequences(urutan, maxlen=max_sent_len)
X_test = pad_sequences(sequences_test, maxlen=max_sent_len)
# 100 adalah ukuran wordvec.

embedding_matrix = np.zeros((vocab_size + 1, 100))
# buat matriks setiap kata dengan vektor_kata untuk model CNN.

# jadi setiap baris matriks akan mewakili satu kata. Akan ada
menjadi satu baris untuk setiap kata dalam
159
halaman 171
#set pelatihan
untuk kata, saya di word_index.items():
mencoba:
embedding_vector = word_vecs[word]
kecuali:
embedding_vector = Tidak ada
jika embedding_vector bukan None:
embedding_matrix[i] = embedding_vector
print("Penanaman selesai")
vocab_size = len(embedding_matrix)
# Model CNN membutuhkan label multiclass untuk diubah menjadi satu

pengkodean panas.
# yaitu setiap kolom mewakili label, dan akan ditandai satu
untuk label yang sesuai.
y = to_categorical(np.asarray(Y_train))
embedding_layer = Menanamkan(vocab_size,
100,
bobot=[embedding_matrix],
input_length=max_sent_len,
dapat dilatih=Benar)
sequence_input = Input(bentuk=(max_sent_len,), dtype='int32')
# susun setiap kata dari kalimat dalam matriks. Jadi setiap matriks
mewakili sebuah kalimat.
# Setiap baris dalam matriks adalah kata (Vektor Kata) dari sebuah kalimat.
embedded_sequences = embedding_layer(masukan_urutan)
# membangun model Konvolusi.

l_cov1 = Conv1D(128, 4, activation='relu')(embedded_sequences)
l_pool1 = MaxPooling1D(4)(l_cov1)
l_flat = Ratakan()(l_pool1)
160
halaman 172
tersembunyi = Padat(100, aktivasi='relu')(l_flat)

preds = Padat(len(y[0]), aktivasi='softmax')(tersembunyi)
model = Model(masukan_urutan, preds)
model.compile(loss='binary_crossentropy',optimizer='Adam')
print("pemasangan model - neural convolutional yang disederhanakan

jaringan")
model.ringkasan()
# melatih model
model.fit(x, y, epochs=10, batch_size=128)
#dapatkan skor dan prediksi.

p = model.predict(X_test)
p = [np.argmax(i) untuk i dalam p]
score_cnn = f1_score(Y_test, p, rata-rata="mikro")
print("skor_akurasi:",skor_akurasi(uji_y, p))
print("f1_skor:", skor_cnn)
Pemasangan model adalah jaringan saraf convolutional yang disederhanakan, sebagai

Lapisan (Tipe) Bentuk Keluaran Param #
masukan_20 (lapisan masukan) (tidak ada, 20) 0
embedding_20 (penyematan) (tidak ada, 20, 100) 2800
konv1d_19 (Konv1D) (tidak ada, 17, 128) 51328
max_pooling1d_19 (Maxpooling) (tidak ada, 4, 128) 0
meratakan_19 (Meratakan) (tidak ada, 512) 0
padat_35 (Padat) (tidak ada, 100) 51300
padat_36 (Padat) (tidak ada, 3) 303
161
halaman 173
Berikut adalah jumlah parameter:
• Total parameter : 105.731
• Parameter yang dapat dilatih : 105.731
• Parameter yang tidak dapat dilatih : 0
Berikut adalah beberapa fungsi penting Word2vec menggunakan Gensim

kemasan:
• Beginilah cara Anda mengimpor Gensim dan memuat yang sudah dilatih
model:
genisme impor
#memuat model yang sudah terlatih
model = gensim.models.KeyedVectors.
load_word2vec_format('GoogleNews-vectors-
negatif300.bin', biner=Benar)
• Ini adalah model yang telah dilatih sebelumnya dari Google untuk
Bahasa Inggris, dan itu adalah 300 dimensi.
• Ini adalah cara mencari vektor kata dari sebuah kata dari a
model terlatih:
# mendapatkan vektor kata dari sebuah kata

singa = model['singa']
cetak(len(singa))
• Berikut adalah cara mencari indeks kesamaan antara dua kata:
#Menghitung indeks kesamaan

print(model.similarity('Raja', 'Ratu'))
162
halaman 174
• Ini adalah cara menemukan yang ganjil dari kumpulan kata:
#Pilih yang aneh

print(model.doesnt_match("Harimau Anggur Mangga
Pisang Strawberry".split()))
• Ini adalah cara menemukan kata yang paling mirip:
print(model.most_similar(positive=[Pangeran,
Cewek], negatif=[Laki-laki]))
Fitur unik Word2vec adalah Anda bisa mendapatkan

vektor, dari vektor lain menggunakan operasi vektor.
Misalnya, vektor "Pangeran" dikurangi vektor
"laki-laki" ditambah vektor "perempuan" akan hampir sama dengan a
vektor "Putri." Oleh karena itu, ketika Anda menghitung ini,
Anda akan mendapatkan vektor "Putri."
Vec ("Pangeran") – Vec("laki-laki") + Vec("perempuan")

Vec("Putri")
Ini hanya sebuah contoh. Kasus ini berlaku di banyak

kasus lain. Ini adalah spesialisasi Word2vec dan adalah
berguna dalam memperkirakan kata-kata yang mirip, kata-kata berikutnya,
generasi bahasa alami (NLG), dan sebagainya.
Tabel 11-1 menunjukkan model pra-pelatihan dengan parameter lain.
163
halaman 175
oogleoogle oogle cinta cinta cinta cinta cinta cinta oldberg

PengarangG G G G G G G G G retribusi G & bodoh
, 5 , 10 , 10 rad rad , 10
oW oW oW oW
Jendela
Ukuran
Konteks
B B B 10+1010+1010+1010+10adag adag sintaksis
Ketergantungan
B
ord2vec
ord2vec, ord2vec, cinta cinta cinta cinta cinta cinta ord2vec ord2vec
Arsitektur W W skip-gram W skip-gram
G G G G G G W W
meter
ra
A
disanaKosakata
P Ukuran3M 1.4M 1.4M 400.000
400.000
400.000
400.000
1.9M2.2M174,000 -
itu O
Corpus
Ukuran100b 100b 100b 6b 6b 6b 6b 42b 840b - -
model w
ined M
Jumlah
Ukuran300 1000 1000 50 100 200 300 300 300 300 1000
t Pra
berbeda
igaword
igaword
5 igaword
5 igaword
5 5
berita
bl 11-1.
oogle n vektor bpedia (wiki2vec)
Ta File ModelG iD gratis Nama freebase
Wikipedia
Wikipedia
Wikipedia
+ g Wikipedia
+ g Perayapan
+ g Perayapan
+ g Ketergantungan
UmumUmum
42b
D 840b Wikipedia
164
halaman 176
Membangun Respon
Respons adalah bagian penting lain dari chatbots. Berdasarkan bagaimana chatbot
balasan, pengguna mungkin tertarik padanya. Setiap kali chatbot dibuat, satu
hal yang harus diingat adalah penggunanya. Anda perlu tahu siapa yang akan
menggunakannya dan untuk tujuan apa akan digunakan. Misalnya, chatbot untuk
situs web restoran hanya akan ditanya tentang restoran dan makanan. Jadi kamu
mengetahui lebih kurang pertanyaan apa yang akan ditanyakan. Oleh karena itu, untuk setiap niat,
Anda menyimpan beberapa jawaban yang dapat digunakan setelah mengidentifikasi maksudnya
sehingga pengguna tidak akan mendapatkan jawaban yang sama berulang kali. Anda juga dapat memiliki
satu maksud untuk pertanyaan di luar konteks; niat itu bisa memiliki banyak
jawaban, dan memilih secara acak, chatbot dapat membalas.
Misalnya, jika maksudnya adalah "halo", Anda dapat memiliki beberapa balasan seperti
sebagai “Halo! Apa kabarmu?" dan “Halo! Apa kabarmu?" dan “Hai! Bagaimana
Bolehkah aku membantumu?"
Chatbot dapat memilih salah satu secara acak untuk balasan.
Dalam kode contoh berikut, Anda mengambil input dari pengguna, tetapi dalam
chatbot asli, maksudnya ditentukan oleh chatbot itu sendiri berdasarkan apa saja
pertanyaan yang diajukan oleh pengguna.
impor acak
maksud = masukan()
output = ["Halo! Apa kabar","Halo! Apa kabar",,"Hai!
Bagaimana saya bisa membantu Anda", "Hei! Di sana", "Haiii", "Halo! Bagaimana bisa saya
membantumu?", "Hei! Ada apa?"]
if(niat == "Hai"):
cetak(pilihan acak(keluaran))
165
halaman 177
Pengembangan Chatbot Menggunakan API

Membuat chatbot bukanlah tugas yang mudah. Anda membutuhkan mata untuk detail dan
ketajaman pikiran untuk membangun chatbot yang dapat dimanfaatkan dengan baik. Ada
dua pendekatan untuk membangun chatbot.
• Pendekatan berbasis aturan
• Pendekatan pembelajaran mesin yang membuat sistem

belajar sendiri dengan menyederhanakan data
Beberapa chatbot bersifat dasar, sementara yang lain lebih canggih

dengan otak AI. Chatbots yang dapat memahami bahasa alami dan
menanggapi mereka menggunakan otak AI, dan penggemar teknologi memanfaatkan
dari berbagai sumber seperti Api.ai untuk membuat chatbot kaya AI tersebut.
Pemrogram memanfaatkan layanan berikut untuk membuat bot:
• Kerangka kerja bot Microsoft
• Wit.ai
• Api.ai
• Watson IBM
Penggemar pembuatan bot lainnya dengan keterampilan pemrograman terbatas atau tidak sama sekali
memanfaatkan platform pengembangan bot seperti berikut ini untuk:
membangun chatbot:
• Bahan Bakar Obrolan
• Teks.in
• Oktan AI
• Motion.ai
166
halaman 178
Ada berbagai API yang menganalisis teks. Tiga raksasa besar adalah sebagai
berikut:
• Layanan Kognitif Microsoft Azure
• Amazon Lex
• IBM Watson
Layanan Kognitif Microsoft Azure
Mari kita mulai dengan Microsoft Azure.
• Layanan Cerdas Pemahaman Bahasa (LUIS) :

Ini menyediakan alat sederhana yang memungkinkan Anda membangun
model bahasa sendiri (maksud/entitas) yang memungkinkan
aplikasi/bot untuk memahami perintah dan tindakan Anda
demikian.
• Text Analytics API : Ini mengevaluasi sentimen dan topik

untuk memahami apa yang diinginkan pengguna.
• API Teks Penerjemah : Ini secara otomatis mengidentifikasi

bahasa dan kemudian menerjemahkannya ke bahasa lain
dalam waktu nyata.
• API Model Bahasa Web : Ini menyisipkan spasi ke dalam a

rangkaian kata yang tidak memiliki spasi secara otomatis.
• Bing Spell Check API : Ini memungkinkan pengguna untuk mengoreksi

kesalahan ejaan; mengenali perbedaan antara nama,
nama merek, dan bahasa gaul; dan memahami homofon
saat mereka mengetik.
• API Analisis Linguistik : Ini memungkinkan Anda untuk mengidentifikasi

konsep dan tindakan dalam teks Anda dengan part-of-
penandaan ucapan dan temukan frasa dan konsep menggunakan
pengurai bahasa alami. Ini sangat berguna untuk menambang
Timbal balik pelanggan.
167
halaman 179
Amazon Lex
Amazon Lex adalah layanan untuk membangun antarmuka percakapan ke dalam
aplikasi menggunakan suara dan teks. Sayangnya, tidak ada sinonim
opsi, dan tidak ada ekstraksi entitas dan klasifikasi maksud yang tepat.
Berikut ini adalah beberapa manfaat penting menggunakan Amazon Lex:
• Itu mudah. Ini memandu Anda dalam membuat chatbot.
• Memiliki algoritma pembelajaran yang mendalam. Algoritma seperti

karena NLU dan NLP diimplementasikan untuk chatbot.
Amazon telah memusatkan fungsi ini sehingga dapat
mudah digunakan.
• Memiliki fitur penyebaran dan penskalaan yang mudah.
• Memiliki integrasi bawaan dengan platform AWS.
• Hemat biaya.
IBM Watson
IBM menyediakan IBM Watson API untuk membuat chatbot Anda sendiri dengan cepat. Di dalam
implementasinya, mendekati perjalanan sama pentingnya dengan
perjalanan itu sendiri. Mendidik diri Anda sendiri tentang Watson Conversational AI untuk
dasar-dasar perusahaan dari desain percakapan, dan dampaknya terhadap bisnis Anda,
penting dalam merumuskan rencana tindakan yang berhasil. Persiapan ini akan
memungkinkan Anda untuk berkomunikasi, belajar, dan memantau dengan standar, memungkinkan
bisnis Anda untuk membangun proyek yang siap untuk pelanggan dan sukses.
Desain percakapan adalah bagian terpenting dalam membangun chatbot.
Hal pertama yang harus dipahami adalah siapa pengguna dan apa yang mereka inginkan
meraih.
IBM Watson memiliki banyak teknologi yang dapat Anda integrasikan dengan mudah
di chatbot Anda; beberapa di antaranya adalah Watson Conversation, Watson Tone
Analyzer, pidato ke teks, dan banyak lagi.
168
halaman 180
Praktik Terbaik Pengembangan Chatbot

Saat membangun chatbot, penting untuk dipahami bahwa ada
praktik terbaik tertentu yang dapat dimanfaatkan. Ini akan membantu dalam membuat
bot ramah pengguna yang berhasil yang dapat memenuhi tujuannya untuk memiliki mulus
percakapan dengan pengguna.
Salah satu hal terpenting dalam hubungan ini adalah mengetahui target audiens
dengan baik. Berikutnya adalah hal-hal lain seperti mengidentifikasi skenario use case,
mengatur nada obrolan, dan mengidentifikasi platform pengiriman pesan.
Dengan mengikuti praktik terbaik berikut, keinginan untuk memastikan
percakapan tanpa batas dengan pengguna dapat menjadi kenyataan.
Kenali Pengguna Potensial

Pemahaman menyeluruh tentang audiens target adalah langkah pertama dalam
membangun bot yang sukses. Tahap selanjutnya adalah mengetahui tujuan yang
bot sedang dibuat.
Berikut adalah beberapa poin yang perlu diingat:
• Ketahui apa tujuan dari bot tertentu. Itu bisa jadi

bot untuk menghibur penonton, memudahkan pengguna bertransaksi,
memberikan berita, atau berfungsi sebagai saluran layanan pelanggan.
• Jadikan bot lebih ramah pelanggan dengan mempelajari tentang

produk pelanggan.
Baca Sentimen Pengguna dan Buat Bot

Memperkaya secara emosional
Chatbot harus hangat dan ramah seperti manusia untuk
membuat percakapan menjadi pengalaman yang luar biasa. Itu juga harus dibaca dengan cerdas
memahami sentimen pengguna untuk mempromosikan blok konten yang dapat meminta
169
halaman 181
pengguna untuk melanjutkan percakapan. Pengguna akan didorong untuk mengunjungi

lagi jika pengalaman itu kaya untuk pertama kalinya.
Berikut adalah beberapa poin yang perlu diingat:
• Promosikan produk Anda atau ubah pengguna menjadi merek
duta besar dengan memanfaatkan sentimen positif.
• Segera tanggapi komentar negatif agar tetap bertahan

permainan percakapan.
• Sebisa mungkin, gunakan bahasa yang ramah untuk membuat

pengguna merasa seperti mereka berinteraksi dengan yang familiar
manusia.
• Buat pengguna merasa nyaman dengan mengulang input dan

memastikan bahwa mereka dapat memahami semuanya
sedang dibahas.
170
halaman 182
BAB 12
Deteksi Wajah dan

Pengakuan
Deteksi wajah adalah proses mendeteksi wajah dalam sebuah gambar atau video.
Pengenalan wajah adalah proses mendeteksi wajah dalam sebuah gambar dan kemudian
menggunakan algoritma untuk mengidentifikasi milik siapa wajah itu. Pengenalan wajah adalah
dengan demikian suatu bentuk identifikasi orang.
Anda harus terlebih dahulu mengekstrak fitur dari gambar untuk melatih
pengklasifikasi pembelajaran mesin untuk mengidentifikasi wajah dalam gambar. Tidak hanya
sistem ini nonsubjektif, tetapi mereka juga otomatis —tidak ada tangan
pelabelan fitur wajah diperlukan. Anda cukup mengekstrak fitur dari
wajah, latih pengklasifikasi Anda, lalu gunakan untuk mengidentifikasi wajah berikutnya.
Karena untuk pengenalan wajah Anda harus terlebih dahulu mendeteksi wajah dari
gambar, Anda dapat menganggap pengenalan wajah sebagai tahap dua fase.
• Tahap 1 : Mendeteksi keberadaan wajah dalam gambar atau
video streaming menggunakan metode seperti Haar cascades,
HOG + SVM Linear, pembelajaran mendalam, atau lainnya
algoritma yang dapat melokalisasi wajah.
• Tahap 2 : Ambil setiap wajah yang terdeteksi selama

fase lokalisasi dan pelajari milik siapa wajah itu
to—inilah tempat Anda benar-benar memberi nama pada wajah.

https://doi.org/10.1007/978-1-4842-3516-4_12
halaman 183
BAB 12 DETEKSI DAN PENGENALAN WAJAH
Deteksi Wajah, Pengenalan Wajah, dan Wajah

Analisis
Ada perbedaan antara deteksi wajah, pengenalan wajah, dan wajah
analisis.
• Deteksi wajah : Ini adalah teknik untuk menemukan semua

wajah manusia dalam sebuah gambar.
• Pengenalan wajah : Ini adalah langkah selanjutnya setelah wajah

deteksi. Dalam pengenalan wajah, Anda mengidentifikasi mana
wajah milik orang mana yang menggunakan gambar yang ada
gudang.
• Analisis wajah : Sebuah wajah diperiksa, dan beberapa kesimpulan

diambil seperti usia, kulit, dan sebagainya.
OpenCV
OpenCV menyediakan tiga metode untuk pengenalan wajah (lihat Gambar 12-1):
• Eigenfaces
• Histogram pola biner lokal (LBPH)
• Fisherfaces
172
halaman 184
Gambar 12-1. Menerapkan metode OpenCV ke wajah
Ketiga metode mengenali wajah dengan membandingkan wajah dengan beberapa

set pelatihan wajah yang dikenal. Untuk pelatihan, Anda menyediakan algoritme dengan
wajah dan label mereka dengan orang yang mereka miliki. Saat Anda menggunakan
algoritma untuk mengenali beberapa wajah yang tidak dikenal, ia menggunakan model yang dilatih
set pelatihan untuk membuat pengakuan. Masing-masing dari tiga yang disebutkan di atas
metode menggunakan set pelatihan sedikit berbeda.
Wajah Laplacian bisa menjadi cara lain untuk mengenali wajah.
Eigenfaces
Algoritma eigenfaces menggunakan analisis komponen utama untuk membangun
representasi gambar wajah berdimensi rendah, yang akan Anda gunakan sebagai
fitur untuk gambar wajah yang sesuai (Gambar 12-2).
173
halaman 185
Gambar 12-2. Menerapkan dekomposisi nilai Eigen dan mengekstraksi 11

eigenface dengan magnitudo terbesar
Untuk ini, Anda mengumpulkan kumpulan data wajah dengan beberapa gambar wajah
setiap orang yang ingin Anda kenali—seperti memiliki banyak pelatihan
contoh kelas gambar yang ingin Anda beri label dalam klasifikasi gambar. Dengan
kumpulan data gambar wajah ini, dianggap memiliki lebar dan tinggi yang sama
dan idealnya dengan mata dan struktur wajah yang sejajar (x,y)
koordinat, Anda menerapkan dekomposisi nilai eigen dari kumpulan data,
menjaga vektor eigen dengan nilai eigen terbesar yang sesuai.
Mengingat vektor eigen ini, wajah kemudian dapat direpresentasikan sebagai linear
kombinasi dari apa yang disebut Kirby dan Sirovich sebagai eigenfaces . Wajah eigen
algoritma melihat seluruh kumpulan data.
174
halaman 186
LBPH
Anda dapat menganalisis setiap gambar secara mandiri di LBPH. Metode LBPH
agak lebih sederhana, dalam arti bahwa Anda mengkarakterisasi setiap gambar di
kumpulan data secara lokal; ketika gambar baru yang tidak dikenal disediakan, Anda melakukan
analisis yang sama di atasnya dan bandingkan hasilnya dengan masing-masing gambar di
Himpunan data. Cara Anda menganalisis gambar adalah dengan mengkarakterisasi lokal
pola di setiap lokasi pada gambar.
Sementara algoritma eigenfaces bergantung pada PCA untuk membangun low-
representasi dimensi gambar wajah, pola biner lokal (LBP)
metode bergantung pada, seperti namanya, ekstraksi fitur.
Pertama kali diperkenalkan oleh Ahonen et al. dalam makalah tahun 2006 “Pengenalan Wajah
dengan Pola Biner Lokal,” metode ini menyarankan untuk membagi gambar wajah menjadi
kisi 7x7 dari sel berukuran sama (Gambar 12-3 ).
Gambar 12-3. Menerapkan LBPH untuk pengenalan wajah dimulai dengan membagi
gambar wajah menjadi kotak 7x7 dari sel berukuran sama
175
halaman 187
Anda kemudian mengekstrak histogram pola biner lokal dari masing-masing 49

sel. Dengan membagi gambar menjadi sel, Anda memperkenalkan lokalitas ke final
vektor fitur. Selanjutnya, sel-sel di tengah memiliki bobot lebih sehingga
mereka berkontribusi lebih pada representasi keseluruhan. Sel di sudut
membawa lebih sedikit informasi identitas wajah dibandingkan dengan sel-sel di tengah
dari grid (yang berisi struktur mata, hidung, dan bibir). Akhirnya, kamu
gabungkan histogram LBP tertimbang ini dari 49 sel untuk membentuk
vektor fitur akhir.
wajah nelayan
Analisis Komponen Utama (PCA), yang merupakan inti dari
Metode Eigenfaces, menemukan kombinasi linear fitur yang memaksimalkan
total varian dalam data. Meskipun ini jelas merupakan cara yang ampuh untuk mewakili
data, itu tidak mempertimbangkan kelas apa pun dan sangat diskriminatif
informasi mungkin hilang saat membuang komponen. Bayangkan sebuah
situasi di mana varians dalam data Anda dihasilkan oleh eksternal
sumber, biarkan itu menjadi cahaya. Komponen yang diidentifikasi oleh PCA tidak
harus mengandung informasi diskriminatif sama sekali, sehingga proyeksi
sampel dioleskan bersama dan klasifikasi menjadi tidak mungkin.
Analisis Diskriminan Linier melakukan kelas-spesifik
pengurangan dimensi dan ditemukan oleh ahli statistik hebat
Pak RA Fisher. Penggunaan beberapa pengukuran dalam taksonomi
masalah. Untuk menemukan kombinasi fitur yang memisahkan
terbaik di antara kelas, Analisis Diskriminan Linier memaksimalkan
rasio antar-kelas ke dalam-kelas tersebar, alih-alih memaksimalkan
sebaran keseluruhan. Idenya sederhana: kelas yang sama harus dikelompokkan
erat bersama, sementara kelas yang berbeda berada sejauh mungkin dari
satu sama lain dalam representasi dimensi yang lebih rendah.
176
halaman 188
Mendeteksi Wajah
Fitur pertama yang Anda perlukan untuk melakukan pengenalan wajah adalah mendeteksi
di mana dalam gambar saat ini ada wajah. Dengan Python Anda dapat menggunakan Haar
filter kaskade dari perpustakaan OpenCV untuk melakukan ini secara efisien.
Untuk implementasi yang ditampilkan di sini, saya menggunakan Anaconda dengan Python 3.5,
OpenCV 3.1.0, dan dlib 19.1.0. Untuk menggunakan kode berikut, pastikan
bahwa Anda memiliki versi ini (atau yang lebih baru).
Untuk melakukan deteksi wajah, beberapa inisialisasi harus dilakukan, seperti:
Sisa kode akan menjadi loop tak terbatas yang terus mendapatkan yang terbaru
gambar dari webcam, mendeteksi semua wajah dalam gambar yang diambil, menggambar
persegi panjang di sekitar wajah terbesar yang terdeteksi, dan akhirnya menunjukkan
masukan, keluaran gambar di jendela (Gambar 12-4 ).
177
halaman 189
Gambar 12-4. Keluaran sampel yang menunjukkan wajah yang terdeteksi
Anda dapat melakukan ini dengan kode berikut dalam infinite loop:
178
halaman 190
Melacak Wajah
Kode deteksi wajah sebelumnya memiliki beberapa kelemahan.
• Kode mungkin mahal secara komputasi.
• Jika orang yang terdeteksi menoleh sedikit,

Kaskade haar mungkin tidak mendeteksi wajah.
• Sulit untuk melacak wajah di antara bingkai.
Pendekatan yang lebih baik untuk ini adalah melakukan deteksi wajah sekali dan
kemudian manfaatkan pelacak korelasi dari perpustakaan dlib yang luar biasa untuk
hanya melacak wajah dari bingkai ke bingkai.
179
halaman 191
Agar ini berfungsi, Anda perlu mengimpor perpustakaan lain dan menginisialisasi
variabel tambahan.
Dalam loop for tak terbatas, Anda sekarang akan menentukan apakah dlib
pelacak korelasi saat ini melacak wilayah dalam gambar. Jika ini adalah
tidak demikian, Anda akan menggunakan kode yang sama seperti sebelumnya untuk menemukan wajah terbesar,
tetapi alih-alih menggambar persegi panjang, Anda menggunakan koordinat yang ditemukan untuk
inisialisasi pelacak korelasi.
180
halaman 192
Sekarang bit terakhir dalam infinite loop adalah untuk memeriksa kembali apakah
pelacak korelasi secara aktif melacak wajah (yaitu, apakah itu hanya mendeteksi a
berhadapan dengan kode sebelumnya, trankingFace=1?). Jika pelacak aktif
melacak wajah di gambar, Anda akan memperbarui pelacak. Tergantung pada
kualitas pembaruan (yaitu, seberapa yakin pelacak tentang apakah itu
masih melacak wajah yang sama), Anda dapat menggambar persegi panjang di sekitar wilayah
ditunjukkan oleh pelacak atau menunjukkan Anda tidak melacak wajah lagi.
181
halaman 193
Seperti yang Anda lihat dalam kode, Anda mencetak pesan ke konsol setiap
kali Anda menggunakan detektor lagi. Jika Anda melihat output dari konsol
saat menjalankan aplikasi ini, Anda akan melihat bahwa meskipun Anda bergerak cukup
sedikit di sekitar layar, pelacaknya cukup bagus dalam mengikuti wajah
sekali terdeteksi.
Pengenalan Wajah
Sistem pengenalan wajah mengidentifikasi nama orang yang ada di
bingkai video dengan mencocokkan wajah di setiap bingkai video dengan yang terlatih
gambar dan mengembalikan (dan menulis dalam file CSV) label jika wajah di
bingkai berhasil dicocokkan. Anda sekarang akan melihat cara membuat wajah
sistem pengenalan langkah demi langkah.
Pertama, Anda mengimpor semua perpustakaan yang diperlukan. pengenalan_wajah adalah
perpustakaan sederhana yang dibangun menggunakan dlibpengenalan wajah canggih juga dibangun
dengan pembelajaran yang mendalam.
Argparse adalah pustaka Python yang memungkinkan Anda menambahkan milik Anda sendiri
argumen ke file; itu kemudian dapat digunakan untuk memasukkan direktori gambar atau a
jalur file pada saat eksekusi.
182
halaman 194
Dalam kode sebelumnya, saat menjalankan file Python ini, Anda harus
tentukan yang berikut: direktori gambar input pelatihan, file video yang
kami akan menggunakan sebagai kumpulan data, dan file CSV keluaran untuk menulis keluaran di masing-masing
jangka waktu.
Dengan menggunakan fungsi sebelumnya, semua file gambar dari folder yang ditentukan
dapat dibaca.
Fungsi berikut menguji frame input dengan pelatihan yang diketahui:
gambar-gambar:
183
halaman 195
Sekarang Anda mendefinisikan fungsi untuk mengekstrak label untuk yang cocok, dikenal
gambar-gambar.
Baca video input untuk mengekstrak frame uji.
Sekarang tentukan label set pelatihan Anda. Kemudian cocokkan dengan yang diekstraksi
frame dari video input yang diberikan untuk mendapatkan hasil yang diinginkan.
184
halaman 196
Pengenalan Wajah Berbasis Pembelajaran Mendalam

Impor paket yang diperlukan.
Inisialisasi variabel.
185
halaman 197
Fungsi label_img() digunakan untuk membuat larik label, dan

detect_faces() fungsi mendeteksi bagian wajah dalam gambar.
Fungsi create_train_data() digunakan untuk pra-pemrosesan
data pelatihan.
186
halaman 198
Fungsi process_test_data() digunakan untuk memproses data pengujian terlebih dahulu.
Kemudian Anda membuat model dan memasukkan data pelatihan ke dalam model.
187
halaman 199
Terakhir, Anda menyiapkan data uji dan memprediksi hasilnya.
Pindah Belajar
Transfer learning memanfaatkan pengetahuan yang diperoleh saat menyelesaikannya
masalah dan menerapkannya pada masalah yang berbeda tetapi terkait.
Di sini Anda akan melihat bagaimana Anda dapat menggunakan jaringan saraf dalam yang telah dilatih sebelumnya
disebut model Inception v3 untuk mengklasifikasikan gambar.
Model Inception cukup mampu mengekstraksi informasi yang berguna
dari sebuah gambar.
Mengapa Pindah Belajar?

Sudah diketahui bahwa jaringan konvolusi membutuhkan sejumlah besar
data dan sumber daya untuk dilatih.
Sudah menjadi norma bagi para peneliti dan praktisi untuk menggunakan
transfer pembelajaran dan fine-tuning (yaitu, mentransfer bobot jaringan
dilatih pada proyek sebelumnya seperti ImageNet ke tugas baru).
188
halaman 200
Anda dapat mengambil dua pendekatan.
• Transfer pembelajaran : Anda dapat mengambil CNN yang memiliki

telah dilatih sebelumnya di ImageNet, hapus yang terakhir sepenuhnya
lapisan terhubung, dan kemudian memperlakukan sisa CNN sebagai
ekstraktor fitur untuk kumpulan data baru. Setelah Anda mengekstrak
fitur untuk semua gambar, Anda melatih pengklasifikasi untuk
kumpulan data baru.
• Penyetelan halus : Anda dapat mengganti dan melatih kembali pengklasifikasi

di atas CNN dan juga menyempurnakan bobot
jaringan yang telah dilatih sebelumnya melalui backpropagation.
Contoh Pembelajaran Transfer

Dalam contoh ini, pertama Anda akan mencoba mengklasifikasikan gambar dengan langsung memuat
Model awal v3.
Impor semua perpustakaan yang diperlukan.
Sekarang tentukan direktori penyimpanan untuk model dan kemudian unduh

Model awal v3.
189
halaman 201
Muat model yang telah dilatih sebelumnya dan tentukan fungsi untuk mengklasifikasikan apa pun
gambar yang diberikan.
Sekarang setelah model didefinisikan, mari kita periksa untuk beberapa gambar.
Ini memberikan hasil yang benar 91,11 persen, tetapi sekarang jika Anda memeriksa beberapa
orang, inilah yang Anda dapatkan:
190
Halaman 202
Ini bola tenis 48,50 persen!

Sayangnya, model Inception sepertinya tidak dapat mengklasifikasikan gambar
dari orang-orang. Alasan untuk ini adalah kumpulan data yang digunakan untuk melatih
Model awal, yang memiliki beberapa label teks yang membingungkan untuk kelas.
Anda dapat menggunakan kembali model Inception yang telah dilatih sebelumnya dan hanya mengganti
lapisan yang melakukan klasifikasi akhir. Ini disebut pembelajaran transfer .
Pertama Anda memasukkan dan memproses gambar dengan model Inception. Hanya
sebelum lapisan klasifikasi akhir dari model Inception, Anda menyimpan
yang disebut nilai transfer ke file cache.
Alasan menggunakan file cache adalah prosesnya lama
gambar dengan model Inception. Ketika semua gambar dalam data baru
set telah diproses melalui model Inception dan hasilnya
nilai transfer disimpan ke file cache, maka Anda dapat menggunakan transfer tersebut
nilai sebagai input ke jaringan saraf lain. Anda kemudian akan melatih
jaringan saraf kedua menggunakan kelas dari kumpulan data baru, jadi
jaringan belajar bagaimana mengklasifikasikan gambar berdasarkan nilai transfer dari
model Inception.
Dengan cara ini, model Inception digunakan untuk mengekstrak informasi yang berguna
dari gambar, dan jaringan saraf lain kemudian digunakan untuk
klasifikasi.
Hitung Nilai Transfer

Impor fungsi transfer_value_cache dari file Inception.
191
halaman 203
Sampai sekarang, nilai transfer disimpan dalam file cache. Sekarang Anda akan
membuat jaringan saraf baru.
Tentukan jaringan.
Berikut cara optimasinya:
Berikut adalah akurasi klasifikasi:
Inilah proses TensorFlow:
192
halaman 204
Berikut adalah fungsi helper untuk melakukan batch training:
Untuk pengoptimalan, berikut adalah kodenya:

193
halaman 205
Untuk memplot matriks kebingungan, berikut adalah kodenya:

194
halaman 206
Berikut adalah fungsi pembantu untuk menghitung klasifikasi:
195
Halaman 207

Sekarang mari kita jalankan.
dari datetime import timedelta
optimalkan(num_iteration=1000)
Langkah Global: 13100, Akurasi Batch Pelatihan: 100,0%

Penggunaan waktu: 0:00:36
print_test_accuracy(show_example_errors=Benar,
show_confusion_matrix=Benar)
196
Halaman 208
Akurasi pada Test-Set: 83,2% (277 / 333)

Contoh kesalahan:
Matriks Kebingungan:
[108 3 5] (0) Aamir Khan
[0 83 22] (1) Salman Khan
[4 22 86] (2) Shahrukh Khan
(0) (1) (2)
Lebah
Banyak API yang mudah digunakan juga tersedia untuk tugas deteksi wajah dan
pengenalan wajah.
Berikut adalah beberapa contoh API deteksi wajah:
• PixLab
• Trueface.ai
• Kairos
• Visi Komputer Microsoft
Berikut adalah beberapa contoh API pengenalan wajah:
• Wajah++
• LambdaLabs
• Kunci Lemon
• PixLab
Jika Anda ingin deteksi wajah, pengenalan wajah, dan analisis wajah dari satu
penyedia, saat ini ada tiga raksasa besar yang memimpin di sini.
• API Pengakuan Amazon Amazon
• API Wajah Microsoft Azure
• API Pengenalan Visual IBM Watson
197
halaman 209
Amazon Recognition API dapat melakukan empat jenis pengenalan.
• Deteksi objek dan pemandangan : Identifikasi pengenalan

berbagai objek menarik seperti kendaraan, hewan peliharaan, atau
furnitur, dan memberikan skor kepercayaan.
• Analisis wajah : Anda dapat menemukan wajah dalam gambar

dan menganalisis atribut wajah, seperti apakah wajah itu
tersenyum atau mata terbuka, dengan keyakinan tertentu
skor.
• Perbandingan wajah : Amazon's Amazon Recognition API

memungkinkan Anda mengukur kemungkinan wajah dalam dua gambar
adalah dari orang yang sama. Sayangnya, kesamaan
ukuran dua wajah orang yang sama tergantung
pada usia pada saat foto. Juga, terlokalisasi
peningkatan iluminasi wajah mengubah hasil
dari perbandingan wajah.
• Pengenalan wajah : API mengidentifikasi orang di

gambar yang diberikan menggunakan repositori pribadi. Ini cepat dan
tepat.
API Wajah Microsoft Azure akan mengembalikan skor kepercayaan untuk seberapa besar kemungkinannya
itu adalah bahwa dua wajah milik satu orang. Microsoft juga memiliki API lain
seperti berikut ini:
• Computer Vision API : Fitur ini mengembalikan informasi

tentang konten visual yang ditemukan dalam sebuah gambar. Itu bisa menggunakan
penandaan, deskripsi, dan model khusus domain untuk
mengidentifikasi konten dan memberi label dengan percaya diri.
• Content Moderation API : Ini berpotensi mendeteksi

gambar yang menyinggung atau tidak diinginkan, teks dalam berbagai
bahasa, dan konten video.
198
halaman 210
• API Emosi : Ini menganalisis wajah untuk mendeteksi berbagai

perasaan dan mempersonalisasi respons aplikasi Anda.
• Video API : Ini menghasilkan output video yang stabil, mendeteksi

gerakan, membuat thumbnail cerdas, dan mendeteksi dan
melacak wajah.
• Pengindeks Video : Ini menemukan wawasan dalam video seperti
entitas ucapan, polaritas sentimen ucapan, dan
garis waktu audio.
• Layanan Visi Kustom : Ini menandai gambar baru berdasarkan

model bawaan atau model yang dibangun melalui pelatihan
kumpulan data yang disediakan oleh Anda.
Visual Recognition API IBM Watson dapat melakukan beberapa deteksi spesifik
seperti berikut ini:
• Dapat menentukan usia orang tersebut.
• Dapat menentukan jenis kelamin orang tersebut.
• Dapat menentukan lokasi kotak pembatas

sekitar wajah.
• Dapat mengembalikan informasi tentang selebriti yang

terdeteksi pada gambar. (Ini tidak dikembalikan ketika a
selebriti tidak terdeteksi.)
199
halaman 211
LAMPIRAN 1
Fungsi Keras untuk

Pengolahan citra
Keras memiliki fungsi yang disebut ImageDataGenerator yang memberi Anda
kumpulan data gambar tensor dengan augmentasi data waktu nyata. Data akan
dilingkari dalam batch tanpa batas.
Berikut adalah fungsinya:
https://doi.org/10.1007/978-1-4842-3516-4
halaman 212
LAMPIRAN 1 FUNGSI KERAS UNTUK PENGOLAHAN GAMBAR
Berikut adalah argumen fungsi:
• featurewise_center: Boolean tipe data. Setel masukan

berarti 0 di atas kumpulan data, dari segi fitur.
• samplewise_center: Boolean tipe data. Tetapkan masing-masing

sampel berarti 0.
• featurewise_std_normalization: Tipe data boolean.

Membagi input dengan std dari kumpulan data, berdasarkan fitur.
• samplewise_std_normalization: Tipe data boolean.

Membagi setiap input dengan std-nya.
• zca_epsilon: Epsilon untuk pemutihan ZCA. Standarnya

adalah 1e-6.
• zca_whitening: boolean. Menerapkan pemutih ZCA.
• rentang_rotasi: int. Tetapkan derajat jangkauan untuk acak

rotasi.
• width_shift_range: Tipe data float (fraksi dari total

lebar). Menetapkan rentang untuk pergeseran horizontal acak.
• height_shift_range: Tipe data float (fraksi dari total

tinggi). Menetapkan rentang untuk pergeseran vertikal acak.
• shear_range: Tipe data float. Mengatur intensitas geser

(sudut geser berlawanan arah jarum jam sebagai radian).
• zoom_range: Tipe data float atau [bawah, atas]. Set

rentang untuk zoom acak. Jika pelampung, [bawah, atas] =
[1-zoom_range, 1+zoom_range].
• channel_shift_range: Tipe data float. Tetapkan rentang untuk

pergeseran saluran acak.
202
halaman 213
• fill_mode: Salah satu dari {"constant", "terdekat",

"mencerminkan" atau "membungkus"}. Titik di luar batas
input diisi sesuai dengan mode yang diberikan.
• cval: Tipe data float atau int. Nilai tersebut digunakan untuk
titik di luar batas saat fill_mode =
"konstan".
• horizontal_flip: Boolean tipe data. Membalik secara acak

masukan secara horizontal.
• vertical_flip: Boolean tipe data. Membalik secara acak

masukan secara vertikal.
• rescale: Faktor rescaling. Ini default ke Tidak Ada. Jika Tidak Ada
atau 0, tidak ada penskalaan ulang yang diterapkan. Jika tidak, Anda berlipat ganda
data dengan nilai yang diberikan (sebelum menerapkan
transformasi lainnya).
• preprocessing_function: Fungsi yang akan diimplikasikan

pada setiap masukan. Fungsi akan berjalan sebelum yang lain
modifikasi di atasnya. Fungsi harus mengambil satu
argumen, gambar (tensor Numpy dengan peringkat 3),
dan harus menampilkan tensor Numpy dengan bentuk yang sama.
• format_data: Salah satu dari {"channels_first", "channels_

last"}. Mode "channels_last" berarti bahwa
gambar harus memiliki bentuk (contoh, tinggi, lebar,
saluran). Mode "channels_first" berarti bahwa
gambar harus memiliki bentuk (sampel, saluran,
tinggi lebar). Ini default ke image_data_
nilai format ditemukan di file konfigurasi Keras Anda di
~/.keras/keras.json. Jika Anda tidak mengaturnya, maka itu akan
menjadi "channels_last".
203
halaman 214
Berikut metode-metodenya:
• fit(x): Menghitung statistik data internal yang terkait dengan

transformasi yang bergantung pada data, berdasarkan array dari
contoh data. Ini diperlukan hanya jika fiturnya_
center atau featurewise_std_normalization atau zca_
memutihkan.
• Berikut adalah argumen metode:
• x: Data sampel. Ini harus memiliki peringkat 4.

Dalam kasus data skala abu-abu, sumbu saluran
harus memiliki nilai 1, dan dalam kasus RGB
data, itu harus memiliki nilai 3.
• augment: Tipe data boolean (default: False).

Ini menetapkan apakah akan muat di augmented secara acak
sampel.
• putaran: Tipe data int (default: 1). Jika augmentasi adalah

set, ini mengatur berapa banyak augmentasi berlalu
atas data yang akan digunakan.
• seed: Tipe data int (default: Tidak ada). Setel a

benih acak.
• flow(x, y): Mengambil data Numpy dan array label dan
menghasilkan kumpulan data yang diperbesar/dinormalisasi.
Menghasilkan batch tanpa batas, dalam loop tak terbatas.
• Berikut argumennya:
• x: Data. Ini harus memiliki peringkat 4. Dalam kasus ini

data skala abu-abu, sumbu saluran harus
memiliki nilai 1, dan dalam kasus data RGB, itu
harus bernilai 3.
• y: Label.
204
halaman 215
• batch_size: Tipe data int (default: 32).
• shuffle: Tipe data boolean (default: True).
• seed: Tipe data int (default: Tidak ada).
• save_to_dir: Tidak ada atau str (default: Tidak ada). Ini

memungkinkan Anda untuk secara optimal menentukan direktori untuk
yang untuk menyimpan gambar yang ditambah menjadi
dihasilkan (berguna untuk memvisualisasikan siapa Anda?
sedang mengerjakan).
• save_prefix: Tipe data str (default: '').

Ini adalah awalan yang digunakan untuk nama file yang disimpan
gambar (hanya relevan jika save_to_dir diatur).
• save_format: Baik png atau jpeg (hanya relevan

jika save_to_dir disetel). Standar: png.
• hasil: Tupel dari (x, y) di mana x adalah Numpy

array data gambar dan y adalah array Numpy
dari label yang sesuai. Putaran generator
tanpa batas waktu.
Fungsi ini akan membantu Anda menambah data gambar secara real time, selama
melatih dirinya sendiri, dengan membuat kumpulan gambar. Ini akan dilewati selama
waktu pelatihan.
Fungsi pemrosesan dapat digunakan untuk menulis beberapa fungsi manual
juga, yang tidak disediakan di perpustakaan Keras.
205
halaman 216
LAMPIRAN 2
Beberapa Gambar Teratas

Set Data Tersedia
• MNIST : Mungkin kumpulan data gambar paling terkenal
tersedia untuk Anda, kumpulan data ini disusun oleh
Yann LeCun dan tim. Kumpulan data ini hampir digunakan
di mana-mana sebagai tutorial atau pengantar di komputer
penglihatan. Ini memiliki sekitar 60.000 gambar pelatihan dan tentang
10.000 gambar uji.
• CIFAR-10 : Kumpulan data ini dibuat sangat terkenal oleh

tantangan ImageNet. Ini memiliki 60.000 gambar 32 × 32 di
10 kelas, dengan 6.000 gambar per kelas. Ada 50.000
gambar pelatihan dan 10.000 gambar uji.
• ImageNet : Database gambar objek berlabel ini adalah

digunakan dalam Pengenalan Visual Skala Besar ImageNet
Tantangan. Ini termasuk objek berlabel, kotak pembatas,
kata deskriptif, dan fitur SIFT. Ada totalnya
dari 14.197.122 kasus.
• MS COCO : Objek Umum Microsoft dalam Konteks

(MS COCO) kumpulan data berisi 91 objek umum
kategori, dengan 82 di antaranya memiliki lebih dari 5.000
contoh berlabel. Secara total, kumpulan data memiliki 2.500.000

https://doi.org/10.1007/978-1-4842-3516-4
halaman 217
LAMPIRAN 2 BEBERAPA SET DATA GAMBAR TERATAS TERSEDIA
instans berlabel dalam 328.000 gambar. Berbeda dengan

kumpulan data ImageNet yang populer, COCO memiliki lebih sedikit kategori
tetapi lebih banyak contoh per kategori. COCO adalah skala besar
deteksi objek, segmentasi, dan kumpulan data teks.
• 10k Wajah Dewasa AS : Kumpulan data ini berisi 10.168

foto wajah alami dan beberapa ukuran
untuk 2.222 wajah, termasuk skor daya ingat,
visi komputer dan atribut fisik, dan tengara
anotasi titik.
• Logo Merek Flickr 32/47 : Ini terdiri dari dunia nyata

gambar yang dikumpulkan dari Flickr dari logo perusahaan di
berbagai keadaan. Muncul dalam dua versi: the
Kumpulan data 32 merek dan kumpulan data 47 merek. Ada
total 8.240 gambar.
• Wajah YouTube : Ini adalah database video wajah

dirancang untuk mempelajari masalah yang tidak dibatasi
pengenalan wajah dalam video. Kumpulan data berisi 3.425
video dari 1.595 orang yang berbeda.
• Caltech Pedestrian : Kumpulan data Caltech Pedestrian

terdiri dari sekitar 10 jam 640x480 30Hz
video yang diambil dari kendaraan yang melewati jalan biasa
lalu lintas di lingkungan perkotaan. Sekitar 250.000 bingkai
(dalam 137 segmen berdurasi sekitar satu menit) dengan
total 350.000 kotak pembatas dan 2.300 unik
pejalan kaki diberi catatan.
• PASCAL VOC : Ini adalah kumpulan data yang sangat besar untuk gambar
tugas klasifikasi. Ini memiliki 500.000 instance data.
208
halaman 218
LAMPIRAN 2 BEBERAPA SET DATA GAMBAR TERATAS TERSEDIA
• Objek Umum Microsoft dalam Konteks (COCO) : It

berisi adegan sehari-hari yang kompleks dari objek umum
dalam konteks alami mereka. Penyorotan objek, pelabelan,
dan klasifikasi menjadi 91 jenis objek. Itu mengandung
2.500.000 kasus.
• Caltech-256 : Ini adalah kumpulan data besar gambar untuk objek

klasifikasi. Gambar dikategorikan dan diurutkan dengan tangan.
Ada total 30.607 gambar.
• Kumpulan data kejahatan FBI : Kumpulan data kejahatan FBI luar biasa.
Jika Anda tertarik dengan analisis data deret waktu, Anda
dapat menggunakannya untuk merencanakan perubahan tingkat kejahatan di tingkat nasional
tingkat di atas periode 20 tahun.
209
halaman 219
LAMPIRAN 3
Pencitraan medis:
Format File DICOM
Pencitraan Digital dan Komunikasi dalam Kedokteran (DICOM) adalah jenis
format file yang digunakan dalam domain medis untuk menyimpan atau mentransfer gambar yang diambil
selama berbagai tes dari beberapa pasien.
Mengapa DICOM?
MRI, CT scan, dan sinar-X dapat disimpan dalam format file normal, tetapi
karena keunikan laporan medis, banyak jenis data yang berbeda
diperlukan untuk gambar tertentu.
Apa Format File DICOM?

Format file ini berisi header yang terdiri dari metadata gambar seperti:
seperti nama pasien, ID, golongan darah, dan sebagainya. Ini juga berisi ruang-
memisahkan nilai piksel dari gambar yang diambil selama berbagai tes medis.

https://doi.org/10.1007/978-1-4842-3516-4
halaman 220
LAMPIRAN 3 CITRA MEDIS: FORMAT FILE DICOM
Standar DICOM adalah format file kompleks yang dapat ditangani oleh
paket berikut:
• pydicom: Ini adalah paket untuk bekerja dengan gambar dalam

Python. dicom adalah versi lama dari paket ini. Sebagai
tulisan ini, pydicom 1. x adalah versi terbaru.
• oro.dicom: Ini adalah paket untuk bekerja dengan

gambar di R
File DICOM direpresentasikan sebagai FileName.dcm
.
212
halaman 221
Indeks
A Api.ai, 166
bisnis, 147
Kognitif Amazon
desain dan fungsi, 146
Jasa, 143– 144
platform pengembangan, 166
Amazon Lex, 168
Facebook Messenger, Slack, dan
Pengakuan Amazon Amazon
Telegram, 146
api, 198
IBM Watson API, 168
Sistem kecerdasan buatan, 145
maksud, 146
Jaringan saraf tiruan (JST), 45
interaksi, 145
Microsoft Azure, 167
B pengguna potensial, 169
teks pra-pemrosesan dan
API Ucapan Bing, 143
pesan
API Pemeriksaan Ejaan Bing, 167
klasifikasi maksud ( lihat
API Pengenalan Suara Bing, 139
Klasifikasi niat,
Membangun model
chatbot)
model linier, 58
NER ( lihat Entitas bernama
regresi logistik, 62
pengakuan (NER))
File python dan impor, 63
menghilangkan tanda baca
langkah TensorFlow, 57
tanda, 148– 149
menghapus kata berhenti,
C 149– 150
Caltech-256, 209 tanggapan, 165

Pejalan Kaki Caltech, 208 tokenisasi, 148
Chatbot diagram alur proses, 147
otak AI, 166 pendekatan berbasis aturan, 166
Amazon Lex, 168 sentimen pengguna, 169

NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 213
https://doi.org/10.1007/978-1-4842-3516-4
halaman 222
INDEKS
Data CIFAR-10 model placeholder, 100

klasifikasi gambar, 110 fungsi prediksi, 102
struktur jaringan, 111 mencatat dan mencetak hasil, 104
Grafik dan sesi komputasi melatih dan menguji fitur set, 98
definisi, 5 lingkaran pelatihan, 103
fitur, 3 variabel, 100
lumpuh, 4 arsitektur model, 112
operasi, 4 model, 97
sesi, 5 lapisan penyatuan, 94
Kode sumber, 6 model terlatih, 113
fase struktur, 4 subsampling, 92, 93
proses kerja, 3 ringkasan, 94
API Visi Komputer, 198 Hitung vektor, 154
API Moderasi Konten, 198 Layanan pidato khusus, 143
Jaringan saraf konvolusi Layanan visi kustom, 199
(CNN), 91
peta aktivasi, 94
D
arsitektur, 95
Data CIFAR-10, 110 Pencitraan Digital dan
lapisan terhubung, 95 Komunikasi dalam
filter dan peta gambar, 92 Kedokteran (DICOM)
API tingkat tinggi, 104 definisi, 211
volume masukan, 94 format berkas, 211

Keras, data MNIST, 105 FileName.dcm, 212
lapisan, 91 paket, 212
data MNIST
fungsi akurasi, 103 E
sesi grafik, 98
Eigenface, 173– 174
fungsi pembantu, 101
API Emosi, 199
klasifikasi gambar, 98
fungsi kerugian, 102
parameter model, 99 F
operasi, 101 Analisis wajah, 172
fungsi pengoptimal, 103 Deteksi wajah
214
halaman 223
INDEKS
API, 197 Fisherfaces, 176

definisi, 171– 172 Logo Merek Flickr 32/47, 208
gambar dari webcam, 177
lingkaran tak terbatas, 177
inisialisasi, 177 G
perpustakaan OpenCV, 177 API Ucapan Google Cloud, 137
pelacakan, 179, 181–182 Google Speech API, 136
Pengenalan wajah
Lebah
Amazon Amazon H
Pengakuan,
Wajah++, 197198 Houndify API, 138
Visual IBM Watson

Pengakuan, 199 AKU J
KeyLemon, 197 IBM Speech to Text API, 138– 139
LambdaLabs, 197 IBM Watson API, 168
Microsoft Azure Layanan IBM Watson, 144
Wajah, 198 Pengenalan Visual IBM Watson
PixLab, 197 API, 199
argparse, 182 GambarNet, 207
Himpunan data, 183 Klasifikasi maksud, chatbot, 152
pembelajaran mendalam, 185– 188 aliran umum, 152– 153
definisi, 171– 172 Word2Vec ( lihat Word2Vec)
file gambar, 183 penyisipan kata, 153– 157
gambar pelatihan yang diketahui, 183
Metode OpenCV ( lihat OpenCV)
perpustakaan yang dibutuhkan, 182 K
transfer pembelajaran ( lihat Transfer Keras, 31
sedang belajar) model pembelajaran yang mendalam
tahap dua fase, 171 kompilasi, 36
bingkai video, 182 evaluasi, 38
video untuk mengekstrak bingkai, 184 memuat data, 33
Kumpulan data kejahatan FBI, 209 definisi model, 34
Penyetelan halus , 188– 189 ramalan, 38
215
halaman 224
INDEKS
Keras ( lanjutan .) propagasi maju, 52

data praproses, 33 parameter, 53
simpan dan muat ulang, 39 perseptron, 50
Langkah, 32 jaringan saraf dangkal, 49
ringkasan, 39 fungsi sigmoid, 49
proses pelatihan, 37 saraf dua lapis
fungsi jaringan, 50
argumen, 202 Model log-linier, 69
pengolahan citra Memori jangka pendek panjang
fungsi, 201 (LSTM), 115, 118
metode, 204 konsep, 118
jaringan saraf, 71 mode, 118
langkah, 40 prediksi urutan
TensorFlow, 42 generasi, 121
arti, 119
prediksi numerik, 120
L
urutan ke urutan
Pemahaman Bahasa
prediksi, 121
Layanan Cerdas jenis, 119
(LUIS), 167 peramalan deret waktu, 122
LBPH, lihat Pola biner lokal
masalah gradien menghilang, 118
histogram (LBPH)
Regresi linier, 58– 62, 71
API Analisis Linguistik, 167 M
Histogram pola biner lokal Pendekatan pembelajaran mesin, 166
(LBPH), 175– 176 Matriks, 16
Regresi logistik, 73 Koefisien cepstral Melfrequency
klasifikasi, 73 (MFCC)
data MNIST mode, 77 konversi audio, 129
Jaringan saraf keras, 74 pengklasifikasi, pengenalan suara,
scikit-belajar, 74 132– 133
Model regresi logistik, 62 fitur dalam Python, 130
masalah klasifikasi biner, 49 parameter, 130– 131
komputasi, 51 Microsoft Azure, 143, 167
216
halaman 225
INDEKS
API Wajah Microsoft Azure, 198 HAI

Objek Umum Microsoft di
OpenCV
Konteks (MS COCO), 207, 209
eigenface, 173– 174
Data MNIST, 84, 207
fisherfaces, 176
klasifikasi gambar, 105
LBPH, 175– 176
arsitektur model, 108
metode, wajah
struktur jaringan, 107 pengakuan, 172– 173
(MLP), 45, 47, 65
jaringan saraf tiruan, 46 P, Q
propagasi balik, 48 VOC PASCAL, 208
diagram alur, 66 sakuSphinx, 135
data iris, 80 pyttsx, 140
model berurutan, 81
kode sumber, 80
R
perpustakaan, 66
Data yang dihasilkan secara acak, 88
model linier, 48
regresi logistik ( lihat Logistik Jaringan saraf berulang
model regresi) (RNN), 115
data MNIST, 84 Arsitektur, 115

konsep, 115
jaringan syaraf, 47, 48
koneksi, 117
data yang dihasilkan secara acak, 88
urutan, 116
vektor masukan tunggal, 48
Fungsi ReLU6, 20
perceptron lapisan tunggal, 47
Fungsi ReLU dan ELU, 19
pelatihan dan pengujian, 68
S
n
SAPI, 140
Pengenalan entitas bernama (NER)
API identifikasi pembicara, 143
definisi, 150
Spektogram
MITIE NER (terlatih), 151
pengklasifikasi, pengenalan suara,
MITIE NER (dilatih sendiri),
132– 133
151– 152
mengkonversi file audio ke gambar,
Stanford NER, 150
133– 134
217
halaman 226
INDEKS
Spektogram ( lanjutan ) hiperbolik tangen dan

definisi, 131 sigmoid, 18
contoh pidato, 134 grafik komputasi dan
Analisis ucapan, 144 sesi, 3
SpeechLib, 140– 141 konstanta, 6
Konversi ucapan-ke-teks fitur, 1
data, 128
keterangan, 128 instalasi, 2
fungsi kerugian (biaya), 22
fitur, 128 daftar, 23
MFCC ( lihat Melfrequency Kode sumber, 23
koefisien cepstral matriks, 16
(MFCC)) metrik
paket sumber terbuka, 135 evaluasi, 28
Google Cloud Speech, 137 daftar, 29
Google Pidato, 136 Kode sumber, 28
Houndify, 138 vs Numpy,4
IBM Speech to Text API, pengoptimal, 25
138– 139 adaptif
Microsoft Bing Speech, 139 teknik, 25
PocketSphinx, 135 regresi linier, 25
Wit.ai API, 137 daftar, 27
parameter, 130– 131 fungsi kerugian, 26
spektogram ( lihat penampung, 9
Spektogram) tensor ( lihat Tensor )
saluran vokal, 128 variabel, 7
Hentikan kata-kata, 149– 150 Tensor, 2
penciptaan, 12
tensor tetap, 13
T, U
acak, 15
TensorFlow, 1
urutan, 14
fungsi aktivasi Istilah Frekuensi-Terbalik
demonstrasi, 17 Frekuensi Dokumen
ReLU6, 20 (TF-IDF), 154– 157
Fungsi ReLU dan ELU, 19
API Analisis Teks, 167
218
halaman 227
INDEKS
Konversi text-to-speech API pidato penerjemah, 143

kode pemotongan audio, 141– 142 API Teks Penerjemah, 167
penyedia layanan kognitif Tokenisasi, 148
Kognitif Amazon
Layanan, 143– 144
layanan IBM Watson, 144 V
Microsoft Azure, 143 API Video, 199
pyttsx, 140 Pengindeks Video, 199
SAPI, 140
PidatoLib, 140– 141
TF-IDF, lihat Istilah Frekuensi-
W, X
Dokumen Terbalik API Model Bahasa Web, 167
Frekuensi (TF-IDF) WER, lihat Tingkat kesalahan kata (WER)
Pindah belajar Wit.ai API, 137
berkas cache, 191 Word2Vec
mengklasifikasikan gambar, 189, 191 saraf konvolusi
definisi, 188– 189 jaringan, 161
Model awal v3, 189 Paket Gensim, 162– 163
model terlatih, 190 Sarung tangan dan CBOW, 157
perpustakaan yang dibutuhkan, 189 pengklasifikasi maksud, CNN, 157,
direktori penyimpanan, 189 159– 161
mentransfer nilai model terlatih dan
matriks kebingungan, 194 parameter, 164– 165
fungsi pembantu, batch fitur unik, 163
pelatihan, 193 Penyematan kata
fungsi pembantu, hitung vektor, 154
klasifikasi, 195 definisi, 153
jaringan saraf, 192 TF-IDF, 154– 157
metode optimasi, 192, 193 Tingkat kesalahan kata (WER), 135
jalankan file, 196
TensorFlow berjalan, 192
transfer_nilai_cache
Y, Z
fungsi, 191 wajah YouTube, 208
219

Pembelajaran Mendalam Dengan Aplikasi Menggunakan Python

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Pembelajaran Mendalam Dengan Aplikasi Menggunakan Python

Diunggah oleh

Hak Cipta:

Format Tersedia

Halaman 1

Navin Kumar Manaswi

Pembelajaran Mendalam dengan Aplikasi Menggunakan Python

ISBN-13 (pbk): 978-1-4842-3515-7 ISBN-13 (elektronik): 978-1-4842-3516-4

Nomor Kontrol Perpustakaan Kongres: 2018938097

Hak Cipta © 2018 oleh Navin Kumar Manaswi

Managing Director, Apress Media LLC: Welmoed Spahr

Sampul dirancang oleh eStudioCalamar

Gambar sampul didesain oleh Freepik (www.freepik.com)

Dicetak pada kertas bebas asam

Tentang Penulis ............................................... .................................xi

Tentang Peninjau Teknis .................................................. .............xiii

Bab 1: Dasar-dasar TensorFlow ............................................ .............1

Grafik Komputasi dan Sesi .................................................. ..........................3

Konstanta, Placeholder, dan Variabel ............................................ ....................6

Tempat penampung ................................................................. ................................................................... ...... 9

Membuat Tensor ................................................... .................................................12

Bekerja pada Matriks ................................................................... .................................................16

Fungsi Aktivasi ................................................................. .................................................17

Fungsi Rugi ................................................................. ................................................................... .. 22

aku aku aku

Pengoptimal ................................................... ................................................................... ........25

Bab 2: Memahami dan Bekerja dengan Keras .........................31

Langkah Tambahan untuk Memperbaiki Model Keras ............................................ .............40

Bab 3: Perceptron Multilayer.................................................. ...........45

Perceptron Lapisan Tunggal .................................................. .................................................47

Perceptron Multilayer ................................................................. .................................................47

Model Regresi Logistik ........................................................ ...................................49

Bab 4: Regresi ke MLP di TensorFlow ........................................57

Regresi Linier di TensorFlow .................................................. ..........................58

Model Regresi Logistik ........................................................ ...................................62

Perceptron Multilayer di TensorFlow .................................................. ....................65

Bab 5: Regresi MLP di Keras .................................................. ....69

Regresi logistik ................................................ ...................................................73

MLP pada Data MNIST (Klasifikasi Digit) ........................................ ................84

Bab 6: Jaringan Saraf Konvolusi .........................................91

Bab 7: CNN di TensorFlow ............................................ ................97

Kode TensorFlow untuk Membangun Pengklasifikasi Gambar untuk Data MNIST........................98

Bab 8: CNN di Keras ............................................ ....................105

Membangun Pengklasifikasi Gambar dengan Data CIFAR-10 ......................................... ....110

Mendefinisikan Model Arsitektur .................................................. .................................112

Bab 9: RNN dan LSTM ............................................ .....................115

Mode LSTM ................................................................... ................................................................... 118

Prediksi Urutan ................................................................. ........................................ 119

Peramalan Time-Series dengan Model LSTM ........................................ ......122

Bab 10: Ucapan ke Teks dan Sebaliknya ......................................127

Ucapan sebagai Data ................................................................... ................................................................... 128

Fitur Pidato: Memetakan Pidato ke Matriks .................................................. ......129

Spektogram: Memetakan Ucapan ke Gambar .................................................. ........131

Membangun Pengklasifikasi untuk Pengenalan Ucapan Melalui Fitur MFCC .............132

Membangun Pengklasifikasi untuk Pengenalan Suara Melalui Spektogram .............133

Konversi Text-to-Speech ............................................ ...................................140

Masa Depan Analisis Ucapan ............................................................ ..................................144

Bab 11: Mengembangkan Chatbots .................................................. ........145

Desain dan Fungsi Chatbots .................................................. .....................146

Langkah-Langkah Membangun Chatbot .................................................. ................................147

Praktik Terbaik Pengembangan Chatbot .................................................. ...............169

Bab 12: Deteksi dan Pengenalan Wajah ...................................171

OpenCV................................................................. ................................................................... ...........172

Mendeteksi Wajah ........................................................ ................................................177

Melacak Wajah ............................................... ...................................................179

Pengenalan Wajah ................................................................... ..................................................182

Pindah Belajar ................................................... ....................................................188

API ................................................................... ................................................................... ................197