![Pembelajaran Mendalam Dengan Aplikasi Menggunakan Python [PDF]](https://pdfs.asia/img/200x200/pembelajaran-mendalam-dengan-aplikasi-menggunakan-python.jpg)
4 0 597 KB
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 https://doi.org/10.1007/978-1-4842-3516-4
ISBN-13 (elektronik): 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 [email protected], 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 [email protected], 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
v
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!
x
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 waktudata 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 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:
1
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
2
halaman 16 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
• 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.
4
halaman 18 BAB 1 DASAR-DASAR TENSORFLOW
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
5
halaman 19 BAB 1 DASAR-DASAR TENSORFLOW
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.
6
halaman 20 BAB 1 DASAR-DASAR TENSORFLOW
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:
7
halaman 21 BAB 1 DASAR-DASAR TENSORFLOW
Sekarang Anda akan menjelajahi bagaimana Anda membuat variabel dan menginisialisasinya. Di sini adalah kode yang melakukannya:
Berikut penjelasan dari kode sebelumnya: 1. Impor modul tensorflow dan beri nama tf. 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(). 5. Buat sesi untuk menghitung nilai. 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:
8
halaman 22 BAB 1 DASAR-DASAR TENSORFLOW
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: 1. Impor modul tensorflow dan beri nama tf. 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. 4. Buat sesi untuk menghitung nilai. 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.
9
halaman 23 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
################# 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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
Anda dapat menghasilkan tensor dari berbagai jenis seperti tensor tetap, tensor acak, dan tensor berurutan.
Tensor Tetap Berikut adalah tensor tetap:
13
halaman 27
BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
21
halaman 35 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 Berikut adalah kode untuk menunjukkan:
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
adalah bahwa Anda tidak perlu menyesuaikan kecepatan belajar tetapi kemungkinan besar dapat mencapai hasil terbaik dengan nilai default.
Contoh Fungsi Rugi Berikut adalah kode untuk menunjukkan:
26
halaman 40 BAB 1 DASAR-DASAR TENSORFLOW
Pengoptimal Umum Berikut adalah daftar pengoptimal umum:
27
halaman 41 BAB 1 DASAR-DASAR TENSORFLOW
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 BAB 1 DASAR-DASAR TENSORFLOW
Metrik Umum Berikut adalah daftar metrik umum:
29
halaman 43
BAB 1 DASAR-DASAR TENSORFLOW
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, dropkeluar, dan normalisasi batch. Mari kita melalui langkah-langkah utama untuk berkembang model pembelajaran mendalam di Keras.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python ,
31
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
Muat Data Berikut adalah cara Anda memuat data:
Praproses Data Berikut adalah cara Anda memproses data sebelumnya:
33
halaman 47 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
Simpan dan Muat Ulang Model Berikut adalah langkah terakhir:
Opsional: Ringkas Modelnya Sekarang mari kita lihat bagaimana meringkas model.
39
halaman 53 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
41
halaman 55 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 pureTensorFlow 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 BAB 2 MEMAHAMI DAN BEKERJA DENGAN KERAS
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 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , https://doi.org/10.1007/978-1-4842-3516-4_3
45
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
BAB 3 PERCEPTRON MULTILAYER
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 satulapisan perceptron.
Perceptron berlapis-lapis 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 BAB 3 PERCEPTRON MULTILAYER
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 BAB 3 PERCEPTRON MULTILAYER
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 BAB 3 PERCEPTRON MULTILAYER
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ù ê ® ëx 2û
éW 1 ê ëW 3
W 2 ù é x 1 ù é B1 ù úê + ê ® W 4 û ë x 2 û ë B2 û
æé W 1 * x 1 + W 2 * x 2 1+ B ù Hai S Cê ú÷ è ë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 BAB 3 PERCEPTRON MULTILAYER
X1' dan X2' menghitung kombinasi linier (Gambar 3-8 ). é x 1' ù ê = ë x 2' û
éw 1 ê ëw 3
w 2ùé x úê w 4ûëx
1ù + 2û
é B1 ù ê ú ë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 BAB 3 PERCEPTRON MULTILAYER
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
a'= [ w 5
é A1 ù 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 BAB 3 PERCEPTRON MULTILAYER
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 BAB 3 PERCEPTRON MULTILAYER
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. = YW
é1 1 ù =ê * [ ]x+ ë1 1 û
é1 ù ê ú adalah model awal. Matriks bobot (2x2) ë1 û
dan matriks bias (2x1) disetel di setiap iterasi. Jadi, kita bisa melihat perubahan dalam matriks bobot dan bias
Inilah langkah 1:
é07. 08 . ù W =ê B ú, = ë06. 12 . û
é 2 .4 ù ê ú ë 3 .2 û
54
halaman 67 BAB 3 PERCEPTRON MULTILAYER
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 . ù W =ê B ú, = ë 03. 13 . û
é 2 .9 ù ê ú ë 4 .0 û
55
halaman 68 BAB 3 PERCEPTRON MULTILAYER
Model akhir setelah w dan b disesuaikan adalah sebagai berikut: é 04. 05 . ù Y= ê * [ ]x+ ë 02. 13 . û
é 3 .0 ù ê ú ë 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.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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).
57
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 BAB 4 REGRESI MLP DI TENSORFLOW
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
BAB 4 REGRESI MLP DI TENSORFLOW
60
halaman 73 BAB 4 REGRESI MLP DI TENSORFLOW
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 BAB 4 REGRESI MLP DI TENSORFLOW
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
BAB 4 REGRESI MLP DI TENSORFLOW
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 BAB 4 REGRESI MLP DI TENSORFLOW
Jika Anda menjalankan kode sebelumnya, plot kerugian lintas entropi terhadap masing-masing zaman terlihat seperti Gambar 4-6 .
64
halaman 77 BAB 4 REGRESI MLP DI TENSORFLOW
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 BAB 4 REGRESI MLP DI TENSORFLOW
Gambar 4-7. Diagram alir untuk MLP Impor semua perpustakaan yang diperlukan. Menerapkan MLP di TensorFlow.
66
halaman 79 BAB 4 REGRESI MLP DI TENSORFLOW
67
halaman 80 BAB 4 REGRESI MLP DI TENSORFLOW
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.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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
69
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 BAB 5 REGRESI MLP DI KERAS
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 BAB 5 REGRESI MLP DI KERAS
Jika Anda menjalankan kode, Anda akan melihat output berikut:
72
halaman 85 BAB 5 REGRESI MLP DI KERAS
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 Buat file Python baru dan impor paket berikut. Yakinkan Anda telah menginstal Keras di sistem Anda.
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 BAB 5 REGRESI MLP DI KERAS
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 BAB 5 REGRESI MLP DI KERAS
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
BAB 5 REGRESI MLP DI KERAS
Jika Anda menjalankan kode, Anda akan melihat output berikut:
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 BAB 5 REGRESI MLP DI KERAS
Data MNIST Mode: Regresi Logistik di Keras Buat file Python baru dan impor paket berikut. Yakinkan Anda telah menginstal Keras di sistem Anda.
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 BAB 5 REGRESI MLP DI KERAS
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
BAB 5 REGRESI MLP DI KERAS
Jika Anda menjalankan kode sebelumnya, Anda akan melihat output berikut: ('train-images-idx3-ubyte.gz', ) _______________________________________________________________ Lapisan (tipe)
Bentuk Keluaran
Param #
================================================== =============== padat_59 (Padat)
(Tidak ada, 256)
200960
_______________________________________________________________ putus_10 (Keluar)
(Tidak ada, 256)
0
_______________________________________________________________ padat_60 (Padat)
(Tidak ada, 512)
131584
_______________________________________________________________ padat_61 (Padat)
(Tidak ada, 10)
5130
================================================== =============== 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 BAB 5 REGRESI MLP DI KERAS
MLP di Data Iris Perceptron multilayer adalah model jaringan saraf minimal. Di dalam bagian, saya akan menunjukkan kodenya.
Tulis Kodenya Buat file Python baru dan impor paket berikut. Yakinkan Anda telah menginstal Keras di sistem Anda.
Muat kumpulan data dengan membaca file CSV menggunakan Pandas.
Tetapkan nilai numerik ke kelas kumpulan data.
Mengkonversi bingkai data ke array.
80
halaman 93 BAB 5 REGRESI MLP DI KERAS
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 BAB 5 REGRESI MLP DI KERAS
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 BAB 5 REGRESI MLP DI KERAS
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:
Jika Anda menjalankan kode, Anda akan melihat output berikut: 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 BAB 5 REGRESI MLP DI KERAS
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. Buat file Python baru dan impor paket berikut. Yakinkan Anda telah menginstal Keras di sistem Anda.
Satu variabel penting didefinisikan.
84
halaman 97 BAB 5 REGRESI MLP DI KERAS
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 BAB 5 REGRESI MLP DI KERAS
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 BAB 5 REGRESI MLP DI KERAS
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 14 detik - rugi: 0,0538 - acc: 0,9886 - val_loss: 0,1241 - val_acc: 0,9814 Zaman 19/20 12 detik - rugi: 0,0522 - acc: 0,9888 - val_loss: 0,1154 - val_acc: 0,9829 Zaman 20/20 13 detik - rugi: 0,0521 - acc: 0,9891 - val_loss: 0,1183 - val_acc: 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 BAB 5 REGRESI MLP DI KERAS
MLP pada Data yang Dihasilkan Secara Acak Buat file Python baru dan impor paket berikut. Yakinkan Anda telah menginstal Keras di sistem Anda.
Buat data menggunakan fungsi acak.
Buat model sekuensial.
Kompilasi modelnya.
Gunakan fungsi model.fit untuk melatih model.
88
halaman 101 BAB 5 REGRESI MLP DI KERAS
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
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python ,
91
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
Bab 6 Jaringan saraf konvolusi
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 Bab 6 Jaringan saraf konvolusi
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 Bab 6 Jaringan saraf konvolusi
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 Bab 6 Jaringan saraf konvolusi
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.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , https://doi.org/10.1007/978-1-4842-3516-4_7
97
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 BAB 7 CNN DALAM TENSORFLOW
# 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 BAB 7 CNN DALAM TENSORFLOW
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 BAB 7 CNN DALAM TENSORFLOW
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 BAB 7 CNN DALAM TENSORFLOW
# 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 BAB 7 CNN DALAM TENSORFLOW
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 BAB 7 CNN DALAM TENSORFLOW
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.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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.
105
impor numpy sebagai np # 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 dari hard import backend sebagai K 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 cetak(X_train.shape) #(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.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 dari keras.layers.normalization impor BatchNormalization #Memperbaiki masalah pemesanan dimensi dari hard import backend sebagai K 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 cetak(X_train.shape) #(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. • Lapisan kolam maksimal memiliki ukuran 2×2.
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. • Lapisan kolam maksimal memiliki ukuran 2×2. • 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(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(32, (5,5), activation='relu', padding = 'sama')) model.add(BatchNormalization()) 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) 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.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , https://doi.org/10.1007/978-1-4842-3516-4_9
halaman 127 Bab 9 rNN dan LStM
115
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”
2,4,6,8
LSTM
“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 numpy sebagai np impor matplotlib.pyplot sebagai plt dari panda impor read_csv impor matematika dari keras.models import Sequential dari keras.layers impor Padat 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
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , https://doi.org/10.1007/978-1-4842-3516-4_10
127
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 BAB 10 PIDATO KE TEKS DAN SEBALIKNYA
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: 1 Mm -(
)=
700 (exp (M / 1125
) - 1)
129
halaman 141 BAB 10 PIDATO KE TEKS DAN SEBALIKNYA
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 BAB 10 PIDATO KE TEKS DAN SEBALIKNYA
• 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 BAB 10 PIDATO KE TEKS DAN SEBALIKNYA
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 Bab 10 Bicara ke teks dan Wakil VerSa
Gambar 10-2. Spektogram sampel pidato Berikut adalah kode Python untuk mengonversi file audio menjadi spektogram:
134
halaman 146 Bab 10 Bicara ke teks dan Wakil VerSa
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 Bab 10 Bicara ke teks dan Wakil VerSa
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)) kecuali sr.UnknownValueError:
print("Google Speech Recognition tidak dapat memahami audio") kecuali sr.RequestError sebagai e: print("Tidak dapat meminta hasil dari Google Speech Layanan pengenalan;{0}".format(e))
136
halaman 148 Bab 10 Bicara ke teks dan Wakil VerSa
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)) kecuali sr.UnknownValueError: print("Google Cloud Speech tidak dapat memahami audio") kecuali sr.RequestError sebagai e: 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)) kecuali sr.UnknownValueError: print("Wit.ai tidak mengerti audio") kecuali sr.RequestError sebagai e: print("Tidak dapat meminta hasil dari layanan Wit.ai; {0}". format)) 137
halaman 149 Bab 10 Bicara ke teks dan Wakil VerSa
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)) kecuali sr.UnknownValueError: print("Houndify tidak mengerti audio") kecuali sr.RequestError sebagai e: 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-XXXXXXXX-XXXX-XXXXXXXXXXXX
138
halaman 150 Bab 10 Bicara ke teks dan Wakil VerSa
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)) kecuali sr.UnknownValueError: print("IBM Speech to Text tidak dapat memahami audio") kecuali sr.RequestError sebagai e: 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)) kecuali sr.UnknownValueError: print("Pengenalan Suara Microsoft Bing tidak bisa mengerti audio") kecuali sr.RequestError sebagai e: 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 Bab 10 Bicara ke teks dan Wakil VerSa
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
Bab 10 Bicara ke teks dan Wakil VerSa
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 Bab 10 Bicara ke teks dan Wakil VerSa
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((endmulai)*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 Bab 10 Bicara ke teks dan Wakil VerSa
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 Bab 10 Bicara ke teks dan Wakil VerSa
• 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
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , https://doi.org/10.1007/978-1-4842-3516-4_11
145
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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
Berikut adalah contoh kodenya: dari nltk.tokenize impor TreebankWordTokenizer dari nltk.corpus mengimpor stopwords l = "Kecerdasan buatan adalah tentang menerapkan matematika!" token = TreebankWordTokenizer().tokenize(l) 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." Berikut adalah contoh kodenya: dari nltk.tokenize impor TreebankWordTokenizer dari nltk.corpus mengimpor stopwords l = "Kecerdasan buatan adalah tentang menerapkan matematika" token = TreebankWordTokenizer().tokenize(l) 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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
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 BAB 11 MENGEMBANGKAN CHATBOT
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
Bab 11 Mengembangkan Chatbot
# 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 impor numpy sebagai np dari keras.preprocessing.text import Tokenizer
157
halaman 169 Bab 11 Mengembangkan Chatbot
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 Bab 11 Mengembangkan Chatbot
# 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 Bab 11 Mengembangkan Chatbot
#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 Bab 11 Mengembangkan Chatbot
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 ditampilkan di sini: 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 Bab 11 Mengembangkan Chatbot
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-vectorsnegatif300.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 Bab 11 Mengembangkan Chatbot
• 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 Bab 11 Mengembangkan Chatbot
oogleoogle PengarangG G
oogle G
, 5 , 10 oW oW Jendela Ukuran Konteks B B
, 10 oW B
cinta cinta cinta cinta cinta cinta oldberg G G G G G G retribusi G & bodoh
rad rad
, 10 oW 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 -
100b
6b
6b
1000
50
100 200 300 300 300 300
itu O Corpus Ukuran100b 100b
6b
6b
42b 840b -
-
model w ined M Jumlah Ukuran300 1000
1000
t Pra
berbeda
igaword igaword 5 igaword 5 igaword 5 5 berita
bl 11-1. vektor bpedia (wiki2vec) oogle n Wikipedia Wikipedia Wikipedia + g Wikipedia + g Perayapan + g Perayapan + g Ketergantungan Umum Umum 42b D 840b Wikipedia Ta File ModelG iD gratis Nama freebase 164
halaman 176 Bab 11 Mengembangkan Chatbot
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 Bab 11 Mengembangkan Chatbot
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 Bab 11 Mengembangkan Chatbot
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-ofpenandaan ucapan dan temukan frasa dan konsep menggunakan pengurai bahasa alami. Ini sangat berguna untuk menambang Timbal balik pelanggan. 167
halaman 179 Bab 11 Mengembangkan Chatbot
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 Bab 11 Mengembangkan Chatbot
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 Bab 11 Mengembangkan Chatbot
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.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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
171
BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 lowrepresentasi 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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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: ditampilkan di sini:
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
Gambar 12-4. Keluaran sampel yang menunjukkan wajah yang terdeteksi Anda dapat melakukan ini dengan kode berikut dalam infinite loop:
178
halaman 190 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
Pengenalan Wajah Berbasis Pembelajaran Mendalam Impor paket yang diperlukan.
Inisialisasi variabel.
185
halaman 197 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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
BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
Berikut adalah fungsi helper untuk melakukan batch training:
Untuk pengoptimalan, berikut adalah kodenya:
193
halaman 205 BAB 12 DETEKSI DAN PENGENALAN WAJAH
Untuk memplot matriks kebingungan, berikut adalah kodenya:
194
halaman 206 BAB 12 DETEKSI DAN PENGENALAN WAJAH
Berikut adalah fungsi pembantu untuk menghitung klasifikasi:
195
Halaman 207 BAB 12 DETEKSI DAN PENGENALAN WAJAH
Sekarang mari kita jalankan. dari datetime import timedelta optimalkan(num_iteration=1000) Langkah Global: 13100, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13200, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13300, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13400, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13500, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13600, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13700, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13800, Akurasi Batch Pelatihan: 100,0% Langkah Global: 13900, Akurasi Batch Pelatihan: 100,0% Langkah Global: 14000, Akurasi Batch Pelatihan: 100,0% Penggunaan waktu: 0:00:36 print_test_accuracy(show_example_errors=Benar, show_confusion_matrix=Benar)
196
Halaman 208 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
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 BAB 12 DETEKSI DAN PENGENALAN WAJAH
• 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:
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , https://doi.org/10.1007/978-1-4842-3516-4
201
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 LAMPIRAN 1 FUNGSI KERAS UNTUK PENGOLAHAN GAMBAR
• 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 LAMPIRAN 1 FUNGSI KERAS UNTUK PENGOLAHAN GAMBAR
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 LAMPIRAN 1 FUNGSI KERAS UNTUK PENGOLAHAN GAMBAR
• 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
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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
207
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 ruangmemisahkan nilai piksel dari gambar yang diambil selama berbagai tes medis.
© Navin Kumar Manaswi 2018 NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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
.
211
212
halaman 221
Indeks A
Api.ai, 166
Kognitif Amazon Jasa, 143– 144 Amazon Lex, 168 Pengakuan Amazon Amazon api, 198 Sistem kecerdasan buatan, 145 Jaringan saraf tiruan (JST), 45
bisnis, 147 desain dan fungsi, 146 platform pengembangan, 166 Facebook Messenger, Slack, dan Telegram, 146 IBM Watson API, 168 maksud, 146 interaksi, 145 Microsoft Azure, 167
B
pengguna potensial, 169
API Ucapan Bing, 143 API Pemeriksaan Ejaan Bing, 167 API Pengenalan Suara Bing, 139 Membangun model model linier, 58 regresi logistik, 62 File python dan impor, 63 langkah TensorFlow, 57
teks pra-pemrosesan dan pesan klasifikasi maksud ( lihat Klasifikasi niat, chatbot) NER ( lihat Entitas bernama pengakuan (NER)) menghilangkan tanda baca tanda, 148– 149 menghapus kata berhenti,
C
149– 150
Caltech-256, 209 Pejalan Kaki Caltech, 208 Chatbot
tanggapan, 165 tokenisasi, 148 diagram alur proses, 147
otak AI, 166
pendekatan berbasis aturan, 166
Amazon Lex, 168
sentimen pengguna, 169
© Navin Kumar Manaswi 2018
213
NK Manaswi, Deep Learning dengan Aplikasi Menggunakan Python , 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 arsitektur, 95 Data CIFAR-10, 110
D Pencitraan Digital dan Komunikasi dalam
lapisan terhubung, 95
Kedokteran (DICOM)
filter dan peta gambar, 92 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 sesi grafik, 98 fungsi pembantu, 101 klasifikasi gambar, 98 fungsi kerugian, 102
E Eigenface, 173– 174 API Emosi, 199
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
AKU J
Pengakuan, 199 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 .) data praproses, 33
propagasi maju, 52 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 Regresi logistik, 73 klasifikasi, 73
Matriks, 16 Koefisien cepstral Melfrequency (MFCC)
data MNIST mode, 77
konversi audio, 129
Jaringan saraf keras, 74
pengklasifikasi, pengenalan suara,
scikit-belajar, 74
132– 133
Model regresi logistik, 62 masalah klasifikasi biner, 49 komputasi, 51
fitur dalam Python, 130 parameter, 130– 131 Microsoft Azure, 143, 167
216
halaman 225 INDEKS
API Wajah Microsoft Azure, 198 Objek Umum Microsoft di Konteks (MS COCO), 207, 209 Data MNIST, 84, 207
HAI OpenCV eigenface, 173– 174 fisherfaces, 176
klasifikasi gambar, 105
LBPH, 175– 176
arsitektur model, 108
metode, wajah pengakuan, 172– 173
struktur jaringan, 107 Perceptron berlapis-lapis (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 perpustakaan, 66 model linier, 48 regresi logistik ( lihat Logistik
R Data yang dihasilkan secara acak, 88 Jaringan saraf berulang (RNN), 115
model regresi)
Arsitektur, 115
data MNIST, 84
konsep, 115 koneksi, 117
jaringan syaraf, 47, 48 data yang dihasilkan secara acak, 88 vektor masukan tunggal, 48 perceptron lapisan tunggal, 47 pelatihan dan pengujian, 68
urutan, 116 Fungsi ReLU6, 20 Fungsi ReLU dan ELU, 19
S
n Pengenalan entitas bernama (NER) definisi, 150 MITIE NER (terlatih), 151 MITIE NER (dilatih sendiri), 151– 152 Stanford NER, 150
SAPI, 140 API identifikasi pembicara, 143 Spektogram pengklasifikasi, pengenalan suara, 132– 133 mengkonversi file audio ke gambar, 133– 134 217
halaman 226 INDEKS
Spektogram ( lanjutan ) definisi, 131 contoh pidato, 134
hiperbolik tangen dan sigmoid, 18 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 spektogram ( lihat Spektogram) saluran vokal, 128 Hentikan kata-kata, 149– 150
fungsi kerugian, 26 penampung, 9 tensor ( lihat Tensor ) variabel, 7 Tensor, 2 penciptaan, 12 tensor tetap, 13
T, U
acak, 15
TensorFlow, 1
urutan, 14
fungsi aktivasi demonstrasi, 17
Istilah Frekuensi-Terbalik Frekuensi Dokumen
ReLU6, 20 Fungsi ReLU dan ELU, 19
(TF-IDF), 154– 157 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 berkas cache, 191 mengklasifikasikan gambar, 189, 191 definisi, 188– 189
Wit.ai API, 137 Word2Vec saraf konvolusi 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 mentransfer nilai matriks kebingungan, 194 fungsi pembantu, batch pelatihan, 193 fungsi pembantu, klasifikasi, 195
159– 161 model terlatih dan parameter, 164– 165 fitur unik, 163 Penyematan kata hitung vektor, 154 definisi, 153
jaringan saraf, 192 metode optimasi, 192, 193
TF-IDF, 154– 157 Tingkat kesalahan kata (WER), 135
jalankan file, 196 TensorFlow berjalan, 192 transfer_nilai_cache fungsi, 191
Y, Z wajah YouTube, 208
219
