Python Deep Learning - Panduan Cepat

Pembelajaran terstruktur mendalam atau pembelajaran hierarki atau pembelajaran mendalam singkatnya adalah bagian dari keluarga metode pembelajaran mesin yang merupakan bagian dari bidang Kecerdasan Buatan yang lebih luas.

Pembelajaran mendalam adalah kelas algoritma pembelajaran mesin yang menggunakan beberapa lapisan unit pemrosesan nonlinier untuk ekstraksi dan transformasi fitur. Setiap lapisan yang berurutan menggunakan keluaran dari lapisan sebelumnya sebagai masukan.

Jaringan saraf dalam, jaringan keyakinan dalam, dan jaringan saraf berulang telah diterapkan pada bidang-bidang seperti computer vision, pengenalan suara, pemrosesan bahasa alami, pengenalan audio, pemfilteran jaringan sosial, terjemahan mesin, dan bioinformatika di mana mereka menghasilkan hasil yang sebanding dengan dan dalam beberapa kasus. lebih baik dari yang dimiliki ahli manusia.

Algoritma dan Jaringan Pembelajaran Mendalam -

• didasarkan pada pembelajaran tanpa pengawasan dari berbagai tingkat fitur atau representasi data. Fitur tingkat yang lebih tinggi diturunkan dari fitur tingkat yang lebih rendah untuk membentuk representasi hierarki.

• menggunakan beberapa bentuk penurunan gradien untuk pelatihan.

Di bab ini, kita akan belajar tentang lingkungan yang diatur untuk Python Deep Learning. Kami harus menginstal perangkat lunak berikut untuk membuat algoritma pembelajaran yang mendalam.

• Python 2.7+
• Scipy dengan Numpy
• Matplotlib
• Theano
• Keras
• TensorFlow

Sangat disarankan agar Python, NumPy, SciPy, dan Matplotlib diinstal melalui distribusi Anaconda. Itu datang dengan semua paket itu.

Kami perlu memastikan bahwa berbagai jenis perangkat lunak diinstal dengan benar.

Mari kita pergi ke program baris perintah kita dan ketik perintah berikut -

$ python
Python 3.6.3 |Anaconda custom (32-bit)| (default, Oct 13 2017, 14:21:34)
[GCC 7.2.0] on linux

Selanjutnya, kita dapat mengimpor pustaka yang diperlukan dan mencetak versinya -

import numpy
print numpy.__version__

Keluaran

1.14.2

Instalasi Theano, TensorFlow dan Keras

Sebelum kita mulai dengan instalasi paket - Theano, TensorFlow dan Keras, kita perlu mengkonfirmasi apakah file pipdipasang. Sistem manajemen paket di Anaconda disebut pip.

Untuk mengonfirmasi pemasangan pip, ketikkan yang berikut di baris perintah -

$ pip

Setelah instalasi pip dikonfirmasi, kita dapat menginstal TensorFlow dan Keras dengan menjalankan perintah berikut -

$pip install theano $pip install tensorflow
$pip install keras

Konfirmasikan pemasangan Theano dengan menjalankan baris kode berikut -

$python –c “import theano: print (theano.__version__)”

Keluaran

1.0.1

Konfirmasikan penginstalan Tensorflow dengan menjalankan baris kode berikut -

$python –c “import tensorflow: print tensorflow.__version__”

Keluaran

1.7.0

Konfirmasikan penginstalan Keras dengan menjalankan baris kode berikut -

$python –c “import keras: print keras.__version__”
Using TensorFlow backend

Keluaran

2.1.5

Artificial Intelligence (AI) adalah kode, algoritma, atau teknik apa pun yang memungkinkan komputer meniru perilaku atau kecerdasan kognitif manusia. Machine Learning (ML) adalah subset dari AI yang menggunakan metode statistik untuk memungkinkan mesin belajar dan meningkatkan dengan pengalaman. Pembelajaran Mendalam adalah bagian dari Pembelajaran Mesin, yang membuat komputasi jaringan saraf multi-lapisan menjadi layak. Pembelajaran Mesin dipandang sebagai pembelajaran yang dangkal sedangkan Pembelajaran Dalam dipandang sebagai pembelajaran hierarkis dengan abstraksi.

Pembelajaran mesin berkaitan dengan berbagai konsep. Konsepnya tercantum di bawah ini -

• supervised
• unsupervised
• pembelajaran penguatan
• regresi linier
• fungsi biaya
• overfitting
• under-fitting
• hyper-parameter, dll.

Dalam pembelajaran yang diawasi, kita belajar memprediksi nilai dari data berlabel. Salah satu teknik ML yang membantu di sini adalah klasifikasi, di mana nilai target adalah nilai yang berbeda; misalnya kucing dan anjing. Teknik lain dalam pembelajaran mesin yang bisa membantu adalah regresi. Regresi bekerja pada nilai target. Nilai target adalah nilai yang berkelanjutan; Misalnya data pasar saham dapat dianalisis dengan menggunakan Regresi.

Dalam pembelajaran tanpa pengawasan, kami membuat kesimpulan dari data masukan yang tidak diberi label atau terstruktur. Jika kita memiliki sejuta rekam medis dan kita harus memahaminya, menemukan struktur yang mendasarinya, pencilan atau mendeteksi anomali, kita menggunakan teknik pengelompokan untuk membagi data ke dalam kelompok yang luas.

Kumpulan data dibagi menjadi set pelatihan, set pengujian, set validasi, dan sebagainya.

Terobosan di tahun 2012 membawa konsep Deep Learning menjadi terkenal. Algoritme mengklasifikasikan 1 juta gambar ke dalam 1000 kategori dengan sukses menggunakan 2 GPU dan teknologi terbaru seperti Big Data.

Mengaitkan Pembelajaran Mendalam dan Pembelajaran Mesin Tradisional

Salah satu tantangan utama yang dihadapi dalam model pembelajaran mesin tradisional adalah proses yang disebut ekstraksi fitur. Programmer harus spesifik dan memberi tahu komputer fitur-fitur yang harus diperhatikan. Fitur ini akan membantu dalam mengambil keputusan.

Memasukkan data mentah ke dalam algoritme jarang berhasil, jadi ekstraksi fitur adalah bagian penting dari alur kerja pembelajaran mesin tradisional.

Ini menempatkan tanggung jawab besar pada programmer, dan efisiensi algoritme sangat bergantung pada seberapa inventif programmer itu. Untuk masalah yang kompleks seperti pengenalan objek atau pengenalan tulisan tangan, ini adalah masalah besar.

Pembelajaran mendalam, dengan kemampuan untuk mempelajari beberapa lapisan representasi, adalah salah satu dari sedikit metode yang telah membantu kami dengan ekstraksi fitur otomatis. Lapisan bawah dapat diasumsikan melakukan ekstraksi fitur otomatis, membutuhkan sedikit atau tanpa panduan dari programmer.

Jaringan Syaraf Tiruan, atau singkatnya jaringan saraf, bukanlah ide baru. Sudah ada sekitar 80 tahun.

Baru pada tahun 2011, Deep Neural Networks menjadi populer dengan penggunaan teknik baru, ketersediaan set data yang besar, dan komputer yang kuat.

Jaringan saraf meniru neuron, yang memiliki dendrit, nukleus, akson, dan akson terminal.

Untuk sebuah jaringan, kita membutuhkan dua neuron. Neuron ini mentransfer informasi melalui sinaps antara dendrit satu dan akson terminal lainnya.

Model yang mungkin dari neuron buatan terlihat seperti ini -

Jaringan saraf akan terlihat seperti yang ditunjukkan di bawah ini -

Lingkaran adalah neuron atau node, dengan fungsinya pada data dan garis / tepi yang menghubungkannya adalah bobot / informasi yang diteruskan.

Setiap kolom adalah lapisan. Lapisan pertama data Anda adalah lapisan masukan. Kemudian, semua lapisan antara lapisan masukan dan lapisan keluaran adalah lapisan tersembunyi.

Jika Anda memiliki satu atau beberapa lapisan tersembunyi, Anda memiliki jaringan saraf yang dangkal. Jika Anda memiliki banyak lapisan tersembunyi, Anda memiliki jaringan saraf yang dalam.

Dalam model ini, Anda memiliki data masukan, Anda membobotnya, dan meneruskannya melalui fungsi di neuron yang disebut fungsi ambang atau fungsi aktivasi.

Pada dasarnya, ini adalah jumlah dari semua nilai setelah membandingkannya dengan nilai tertentu. Jika Anda menembakkan sinyal, maka hasilnya adalah (1) keluar, atau tidak ada yang ditembakkan, maka (0). Itu kemudian diberi bobot dan diteruskan ke neuron berikutnya, dan jenis fungsi yang sama dijalankan.

Kita dapat memiliki fungsi sigmoid (bentuk-s) sebagai fungsi aktivasi.

Adapun bobot, mereka hanya acak untuk memulai, dan mereka unik per masukan ke dalam node / neuron.

Dalam "umpan maju" tipikal, jenis jaringan neural yang paling dasar, informasi Anda diteruskan langsung melalui jaringan yang Anda buat, dan Anda membandingkan keluarannya dengan apa yang Anda harapkan dari keluaran akan menggunakan data sampel Anda.

Dari sini, Anda perlu menyesuaikan bobot untuk membantu Anda mendapatkan keluaran agar sesuai dengan keluaran yang Anda inginkan.

Tindakan mengirim data langsung melalui jaringan saraf disebut a feed forward neural network.

Data kita beralih dari masukan, ke lapisan, secara berurutan, lalu ke keluaran.

Saat kita mundur dan mulai menyesuaikan bobot untuk meminimalkan kerugian / biaya, inilah yang disebut back propagation.

Ini adalah sebuah optimization problem. Dengan jaringan saraf, dalam praktik nyata, kita harus berurusan dengan ratusan ribu variabel, atau jutaan, atau lebih.

Solusi pertama adalah dengan menggunakan penurunan gradien stokastik sebagai metode optimasi. Sekarang, ada opsi seperti AdaGrad, Adam Optimizer, dan sebagainya. Bagaimanapun, ini adalah operasi komputasi besar-besaran. Itulah sebabnya Jaringan Neural sebagian besar ditinggalkan di rak selama lebih dari setengah abad. Baru belakangan ini kami bahkan memiliki kekuatan dan arsitektur di mesin kami untuk mempertimbangkan melakukan operasi ini, dan kumpulan data berukuran tepat agar cocok.

Untuk tugas klasifikasi sederhana, jaringan neural memiliki kinerja yang relatif dekat dengan algoritme sederhana lainnya seperti K Neighbours Terdekat. Kegunaan sebenarnya dari jaringan neural terwujud saat kita memiliki data yang jauh lebih besar, dan pertanyaan yang jauh lebih kompleks, yang keduanya mengungguli model pembelajaran mesin lainnya.

Jaringan neural dalam (DNN) adalah ANN dengan beberapa lapisan tersembunyi antara lapisan masukan dan keluaran. Mirip dengan ANN dangkal, DNN dapat membuat model hubungan non-linier yang kompleks.

Tujuan utama jaringan neural adalah untuk menerima sekumpulan masukan, melakukan penghitungan yang semakin kompleks, dan memberikan keluaran untuk memecahkan masalah dunia nyata seperti klasifikasi. Kami membatasi diri untuk meneruskan jaringan saraf.

Kami memiliki masukan, keluaran, dan aliran data sekuensial di jaringan dalam.

Jaringan saraf banyak digunakan dalam pembelajaran yang diawasi dan penguatan masalah pembelajaran. Jaringan ini didasarkan pada sekumpulan lapisan yang terhubung satu sama lain.

Dalam pembelajaran mendalam, jumlah lapisan tersembunyi, kebanyakan non-linier, bisa sangat besar; katakanlah sekitar 1000 lapisan.

Model DL menghasilkan hasil yang jauh lebih baik daripada jaringan ML normal.

Kami kebanyakan menggunakan metode penurunan gradien untuk mengoptimalkan jaringan dan meminimalkan fungsi kerugian.

Kita bisa menggunakan Imagenet, gudang jutaan gambar digital untuk mengklasifikasikan kumpulan data ke dalam kategori seperti kucing dan anjing. Jaringan DL semakin banyak digunakan untuk gambar dinamis selain yang statis dan untuk deret waktu dan analisis teks.

Melatih kumpulan data merupakan bagian penting dari model Pembelajaran Mendalam. Selain itu, Backpropagation adalah algoritme utama dalam melatih model DL.

DL menangani pelatihan jaringan neural besar dengan transformasi input output yang kompleks.

Salah satu contoh DL adalah pemetaan foto ke nama orang dalam foto seperti yang mereka lakukan di jejaring sosial dan mendeskripsikan gambar dengan frasa adalah aplikasi DL terbaru lainnya.

Jaringan neural adalah fungsi yang memiliki input seperti x1, x2, x3… yang diubah menjadi output seperti z1, z2, z3, dan seterusnya dalam dua (jaringan dangkal) atau beberapa operasi perantara yang juga disebut lapisan (jaringan dalam).

Bobot dan bias berubah dari lapisan ke lapisan. 'w' dan 'v' adalah bobot atau sinapsis dari lapisan jaringan saraf.

Kasus penggunaan terbaik dari pembelajaran mendalam adalah masalah pembelajaran yang diawasi. Di sini, kami memiliki sejumlah besar input data dengan serangkaian output yang diinginkan.

Di sini kami menerapkan algoritma propagasi balik untuk mendapatkan prediksi keluaran yang benar.

Kumpulan data paling dasar dari pembelajaran mendalam adalah MNIST, kumpulan data dari digit tulisan tangan.

Kita dapat melatih Jaringan Neural Konvolusional dengan Keras untuk mengklasifikasikan gambar digit tulisan tangan dari kumpulan data ini.

Pengaktifan atau aktivasi pengklasifikasi jaringan saraf menghasilkan skor. Misalnya, untuk mengklasifikasikan pasien sakit dan sehat, kami mempertimbangkan parameter seperti tinggi badan, berat badan dan suhu tubuh, tekanan darah, dll.

Skor tinggi berarti pasien sakit dan skor rendah berarti sehat.

Setiap node dalam output dan lapisan tersembunyi memiliki pengklasifikasi sendiri. Lapisan masukan mengambil masukan dan meneruskan skornya ke lapisan tersembunyi berikutnya untuk aktivasi lebih lanjut dan ini berlangsung hingga keluaran tercapai.

Kemajuan dari input ke output dari kiri ke kanan dalam arah maju disebut forward propagation.

Credit assignment path (CAP) pada neural network merupakan rangkaian transformasi yang dimulai dari input hingga output. CAPs menguraikan kemungkinan hubungan sebab akibat antara input dan output.

Kedalaman CAP untuk jaringan neural umpan maju yang diberikan atau kedalaman CAP adalah jumlah lapisan tersembunyi ditambah satu sebagai lapisan keluaran disertakan. Untuk jaringan neural berulang, di mana sinyal dapat merambat melalui lapisan beberapa kali, kedalaman CAP berpotensi tidak terbatas.

Jaring Dalam dan Jaring Dangkal

Tidak ada ambang batas kedalaman yang jelas yang memisahkan pembelajaran dangkal dari pembelajaran dalam; tetapi sebagian besar disepakati bahwa untuk pembelajaran mendalam yang memiliki beberapa lapisan non-linier, CAP harus lebih besar dari dua.

Simpul dasar dalam jaringan saraf adalah persepsi yang meniru neuron dalam jaringan saraf biologis. Kemudian kami memiliki Persepsi atau MLP berlapis-lapis. Setiap set input dimodifikasi oleh satu set bobot dan bias; setiap sisi memiliki bobot yang unik dan setiap node memiliki bias yang unik.

Prediksinya accuracy jaringan saraf tergantung padanya weights and biases.

Proses meningkatkan akurasi jaringan saraf disebut training. Output dari jaring penyangga maju dibandingkan dengan nilai yang diketahui benar.

Itu cost function or the loss function adalah perbedaan antara keluaran yang dihasilkan dan keluaran aktual.

Inti dari pelatihan adalah membuat biaya pelatihan sekecil mungkin di jutaan contoh pelatihan. Untuk melakukan ini, jaringan menyesuaikan bobot dan bias hingga prediksi cocok dengan keluaran yang benar.

Setelah dilatih dengan baik, jaringan saraf berpotensi membuat prediksi yang akurat setiap saat.

Ketika polanya menjadi kompleks dan Anda ingin komputer Anda mengenalinya, Anda harus menggunakan jaringan neural. Dalam skenario pola yang kompleks seperti itu, jaringan saraf mengungguli semua algoritme pesaing lainnya.

Sekarang ada GPU yang bisa melatih mereka lebih cepat dari sebelumnya. Jaringan neural dalam sudah merevolusi bidang AI

Komputer telah terbukti pandai melakukan kalkulasi berulang dan mengikuti instruksi terperinci tetapi tidak begitu pandai dalam mengenali pola yang rumit.

Jika ada masalah pengenalan pola sederhana, mesin vektor dukungan (svm) atau pengklasifikasi regresi logistik dapat melakukan pekerjaan dengan baik, tetapi karena kompleksitas pola meningkat, tidak ada cara lain selain menggunakan jaringan saraf yang dalam.

Oleh karena itu, untuk pola kompleks seperti wajah manusia, jaringan saraf dangkal gagal dan tidak memiliki alternatif selain menggunakan jaringan saraf dalam dengan lebih banyak lapisan. Jaring dalam mampu melakukan tugasnya dengan memecah pola kompleks menjadi pola yang lebih sederhana. Misalnya wajah manusia; adeep net akan menggunakan tepian untuk mendeteksi bagian-bagian seperti bibir, hidung, mata, telinga, dan sebagainya, lalu menggabungkannya kembali untuk membentuk wajah manusia.

Keakuratan prediksi yang benar telah menjadi begitu akurat sehingga baru-baru ini di Google Pattern Recognition Challenge, jaring yang dalam mengalahkan manusia.

Ide tentang jaringan perceptron berlapis ini telah ada selama beberapa waktu; di area ini, jaring yang dalam meniru otak manusia. Tapi satu kelemahan dari ini adalah mereka membutuhkan waktu lama untuk berlatih, kendala perangkat keras

Namun GPU berperforma tinggi baru-baru ini telah mampu melatih jaring yang begitu dalam kurang dari seminggu; sementara fast cpus bisa memakan waktu berminggu-minggu atau mungkin berbulan-bulan untuk melakukan hal yang sama.

Memilih Deep Net

Bagaimana cara memilih jaring yang dalam? Kami harus memutuskan apakah kami sedang membangun pengklasifikasi atau jika kami mencoba menemukan pola dalam data dan jika kami akan menggunakan pembelajaran tanpa pengawasan. Untuk mengekstrak pola dari sekumpulan data yang tidak berlabel, kami menggunakan mesin Boltzman Terbatas atau pembuat enkode Otomatis.

Pertimbangkan poin-poin berikut saat memilih jaring dalam -

• Untuk pemrosesan teks, analisis sentimen, penguraian, dan pengenalan entitas nama, kami menggunakan jaringan tensor neural jaringan atau rekursif berulang atau RNTN;

• Untuk setiap model bahasa yang beroperasi pada level karakter, kami menggunakan jaringan berulang.

• Untuk pengenalan gambar, kami menggunakan DBN jaringan keyakinan dalam atau jaringan konvolusional.

• Untuk pengenalan objek, kami menggunakan RNTN atau jaringan konvolusional.

• Untuk pengenalan suara, kami menggunakan jaringan berulang.

Secara umum, jaringan kepercayaan dalam dan perceptron multilayer dengan unit linier yang diperbaiki atau RELU keduanya merupakan pilihan yang baik untuk klasifikasi.

Untuk analisis deret waktu, selalu disarankan untuk menggunakan jaringan berulang.

Jaringan saraf telah ada selama lebih dari 50 tahun; tapi baru sekarang mereka menjadi terkenal. Alasannya adalah karena mereka sulit untuk dilatih; ketika kita mencoba melatihnya dengan metode yang disebut propagasi mundur, kita mengalami masalah yang disebut gradien lenyap atau meledak. Bila itu terjadi, pelatihan membutuhkan waktu lebih lama dan keakuratan mengambil tempat di belakang. Saat melatih kumpulan data, kami terus menghitung fungsi biaya, yang merupakan selisih antara keluaran yang diprediksi dan keluaran aktual dari sekumpulan data pelatihan berlabel. Fungsi biaya kemudian diminimalkan dengan menyesuaikan nilai bobot dan bias hingga nilai terendah diperoleh. Proses pelatihan menggunakan gradien, yaitu tingkat di mana biaya akan berubah sehubungan dengan perubahan bobot atau nilai bias.

Jaringan Boltzman atau Autoencoder Terbatas - RBN

Pada tahun 2006, sebuah terobosan telah dicapai dalam mengatasi masalah gradien yang hilang. Geoff Hinton merancang strategi baru yang mengarah pada pengembanganRestricted Boltzman Machine - RBM, jaring dua lapis yang dangkal.

Lapisan pertama adalah visible lapisan dan lapisan kedua adalah hiddenlapisan. Setiap node di lapisan yang terlihat terhubung ke setiap node di lapisan tersembunyi. Jaringan dikenal sebagai jaringan terbatas karena tidak ada dua lapisan dalam lapisan yang sama yang diizinkan untuk berbagi koneksi.

Autoencoder adalah jaringan yang menyandikan data masukan sebagai vektor. Mereka membuat representasi data mentah yang tersembunyi, atau terkompresi. Vektor berguna dalam reduksi dimensi; vektor memampatkan data mentah menjadi sejumlah kecil dimensi penting. Autoencoder dipasangkan dengan decoder, yang memungkinkan rekonstruksi data input berdasarkan representasi tersembunyinya.

RBM adalah padanan matematika dari penerjemah dua arah. Sebuah forward pass mengambil input dan menerjemahkannya menjadi satu set angka yang mengkodekan input. Sementara itu, backward pass mengambil rangkaian angka ini dan menerjemahkannya kembali menjadi input yang direkonstruksi. Jaring yang terlatih melakukan penyangga punggung dengan tingkat akurasi yang tinggi.

Dalam kedua langkah tersebut, bobot dan bias memiliki peran penting; mereka membantu RBM dalam memecahkan kode keterkaitan antara input dan dalam memutuskan input mana yang penting dalam mendeteksi pola. Melalui forward dan backward pass, RBM dilatih untuk membangun kembali masukan dengan bobot dan bias yang berbeda hingga masukan dan konstruksi sedekat mungkin. Aspek yang menarik dari RBM adalah bahwa data tidak perlu diberi label. Ini ternyata sangat penting untuk kumpulan data dunia nyata seperti foto, video, suara, dan data sensor, yang semuanya cenderung tidak berlabel. Alih-alih memberi label data secara manual oleh manusia, RBM secara otomatis menyortir data; dengan menyesuaikan bobot dan bias dengan benar, RBM dapat mengekstrak fitur penting dan merekonstruksi input. RBM adalah bagian dari keluarga jaringan saraf ekstraktor fitur, yang dirancang untuk mengenali pola yang melekat dalam data. Ini juga disebut pembuat enkode otomatis karena harus menyandikan strukturnya sendiri.

Deep Belief Networks - DBN

Jaringan keyakinan mendalam (DBN) dibentuk dengan menggabungkan RBM dan memperkenalkan metode pelatihan yang cerdas. Kami memiliki model baru yang akhirnya memecahkan masalah gradien lenyap. Geoff Hinton menemukan RBM dan Deep Belief Nets sebagai alternatif untuk propagasi mundur.

DBN memiliki struktur yang mirip dengan MLP (Multi-layer perceptron), tetapi sangat berbeda dalam hal pelatihan. Ini adalah pelatihan yang memungkinkan DBN untuk mengungguli rekan-rekan mereka yang dangkal

DBN dapat divisualisasikan sebagai tumpukan RBM di mana lapisan tersembunyi dari salah satu RBM adalah lapisan RBM yang terlihat di atasnya. RBM pertama dilatih untuk merekonstruksi masukannya seakurat mungkin.

Lapisan tersembunyi dari RBM pertama diambil sebagai lapisan yang terlihat dari RBM kedua dan RBM kedua dilatih menggunakan keluaran dari RBM pertama. Proses ini diulangi sampai setiap lapisan dalam jaringan dilatih.

Dalam DBN, setiap RBM mempelajari seluruh input. DBN bekerja secara global dengan menyelaraskan seluruh input secara berurutan saat model secara perlahan meningkat seperti lensa kamera yang secara perlahan memfokuskan gambar. Tumpukan RBM mengungguli RBM tunggal karena MLP perceptron multi-layer mengungguli satu perceptron.

Pada tahap ini, RBM telah mendeteksi pola yang melekat dalam data tetapi tanpa nama atau label. Untuk menyelesaikan pelatihan DBN, kami harus memperkenalkan label pada pola dan menyempurnakan jaringan dengan pembelajaran yang diawasi.

Kami membutuhkan sekumpulan kecil sampel berlabel sehingga fitur dan pola dapat dikaitkan dengan sebuah nama. Kumpulan data berlabel kecil ini digunakan untuk pelatihan. Kumpulan data berlabel ini bisa sangat kecil jika dibandingkan dengan kumpulan data asli.

Bobot dan bias diubah sedikit, menghasilkan perubahan kecil dalam persepsi pola jaringan dan seringkali sedikit peningkatan dalam akurasi total.

Pelatihan juga dapat diselesaikan dalam waktu yang wajar dengan menggunakan GPU yang memberikan hasil yang sangat akurat dibandingkan dengan jaring dangkal dan kami juga melihat solusi untuk menghilangkan masalah gradien.

Generative Adversarial Networks - GANs

Jaringan permusuhan generatif adalah jaringan saraf dalam yang terdiri dari dua jaring, diadu satu dengan yang lain, sehingga disebut "permusuhan".

GAN diperkenalkan dalam sebuah makalah yang diterbitkan oleh para peneliti di University of Montreal pada tahun 2014. Pakar AI Facebook Yann LeCun, mengacu pada GAN, menyebut pelatihan adversarial sebagai "ide paling menarik dalam 10 tahun terakhir di ML."

Potensi GAN sangat besar, karena pemindaian jaringan belajar untuk meniru distribusi data apa pun. GAN dapat diajarkan untuk menciptakan dunia paralel yang sangat mirip dengan dunia kita di domain apa pun: gambar, musik, ucapan, prosa. Mereka adalah seniman robot, dan hasil mereka cukup mengesankan.

Dalam GAN, satu jaringan neural, yang dikenal sebagai generator, menghasilkan instance data baru, sementara yang lain, diskriminator, mengevaluasi keasliannya.

Misalkan kita mencoba untuk menghasilkan angka tulisan tangan seperti yang ditemukan di dataset MNIST, yang diambil dari dunia nyata. Pekerjaan diskriminator, ketika ditunjukkan contoh dari dataset MNIST yang sebenarnya, adalah untuk mengenali mereka sebagai asli.

Sekarang pertimbangkan langkah-langkah GAN berikut -

• Jaringan generator mengambil input dalam bentuk bilangan acak dan mengembalikan gambar.

• Gambar yang dihasilkan ini diberikan sebagai masukan ke jaringan diskriminator bersama dengan aliran gambar yang diambil dari dataset yang sebenarnya.

• Diskriminator mengambil gambar asli dan palsu serta probabilitas pengembalian, angka antara 0 dan 1, dengan 1 mewakili prediksi keaslian dan 0 mewakili palsu.

• Jadi Anda memiliki umpan balik ganda -

  • Diskriminator berada dalam lingkaran umpan balik dengan kebenaran dasar gambar, yang kita ketahui.

  • Generator berada dalam loop umpan balik dengan diskriminator.

Jaringan Neural Berulang - RNN

RNNSare jaringan saraf di mana data dapat mengalir ke segala arah. Jaringan ini digunakan untuk aplikasi seperti pemodelan bahasa atau Natural Language Processing (NLP).

Konsep dasar yang mendasari RNN adalah memanfaatkan informasi berurutan. Dalam jaringan saraf normal diasumsikan bahwa semua input dan output tidak bergantung satu sama lain. Jika kita ingin memprediksi kata berikutnya dalam sebuah kalimat, kita harus tahu kata mana yang muncul sebelumnya.

RNN disebut berulang karena mereka mengulangi tugas yang sama untuk setiap elemen dari suatu urutan, dengan keluaran yang didasarkan pada perhitungan sebelumnya. Dengan demikian RNN dapat dikatakan memiliki "memori" yang menangkap informasi tentang apa yang telah dihitung sebelumnya. Secara teori, RNN dapat menggunakan informasi dalam urutan yang sangat panjang, tetapi kenyataannya, RNN hanya dapat melihat beberapa langkah ke belakang.

Jaringan memori jangka pendek (LSTM) adalah RNN yang paling umum digunakan.

Bersama dengan Jaringan Neural konvolusional, RNN telah digunakan sebagai bagian dari model untuk menghasilkan deskripsi untuk gambar yang tidak berlabel. Sungguh menakjubkan seberapa baik ini tampaknya bekerja.

Convolutional Deep Neural Networks - CNN

Jika kita menambah jumlah lapisan di jaringan saraf untuk membuatnya lebih dalam, itu meningkatkan kompleksitas jaringan dan memungkinkan kita untuk memodelkan fungsi yang lebih rumit. Namun, jumlah bobot dan bias akan meningkat secara eksponensial. Faktanya, mempelajari masalah yang sulit seperti itu bisa menjadi tidak mungkin untuk jaringan saraf normal. Ini mengarah pada solusi, jaringan saraf konvolusional.

CNN banyak digunakan dalam computer vision; telah diterapkan juga dalam pemodelan akustik untuk pengenalan suara otomatis.

Ide di balik jaringan saraf konvolusional adalah ide "filter bergerak" yang melewati gambar. Filter bergerak ini, atau konvolusi, berlaku untuk lingkungan node tertentu yang misalnya mungkin piksel, di mana filter yang diterapkan adalah 0,5 x nilai node -

Peneliti terkemuka Yann LeCun memelopori jaringan saraf konvolusional. Facebook sebagai software pengenal wajah menggunakan jaring tersebut. CNN telah menjadi solusi utama untuk proyek-proyek visi mesin. Ada banyak lapisan pada jaringan konvolusional. Dalam tantangan Imagenet, sebuah mesin mampu mengalahkan manusia pada pengenalan objek pada tahun 2015.

Singkatnya, Convolutional Neural Networks (CNNs) adalah jaringan saraf multi-layer. Lapisannya terkadang hingga 17 atau lebih dan menganggap data masukan berupa gambar.

CNN secara drastis mengurangi jumlah parameter yang perlu disetel. Jadi, CNN secara efisien menangani dimensi tinggi dari gambar mentah.

Di bab ini, kita akan melihat dasar-dasar Python Deep Learning.

Model / algoritma pembelajaran mendalam

Sekarang mari kita belajar tentang model / algoritma pembelajaran mendalam yang berbeda.

Beberapa model populer dalam pembelajaran mendalam adalah sebagai berikut -

• Jaringan saraf konvolusional
• Jaringan saraf berulang
• Jaringan kepercayaan yang dalam
• Jaringan permusuhan generatif
• Pembuat enkode otomatis dan sebagainya

Input dan output direpresentasikan sebagai vektor atau tensor. Misalnya, jaringan neural mungkin memiliki input di mana nilai RGB piksel individual dalam gambar direpresentasikan sebagai vektor.

Lapisan neuron yang terletak di antara lapisan masukan dan lapisan keluaran disebut lapisan tersembunyi. Di sinilah sebagian besar pekerjaan terjadi ketika jaringan saraf mencoba menyelesaikan masalah. Melihat lebih dekat pada lapisan tersembunyi dapat mengungkapkan banyak hal tentang fitur yang telah dipelajari jaringan untuk diekstrak dari data.

Arsitektur berbeda dari jaringan saraf dibentuk dengan memilih neuron mana yang akan dihubungkan ke neuron lain di lapisan berikutnya.

Pseudocode untuk menghitung keluaran

Berikut adalah pseudocode untuk menghitung keluaran Forward-propagating Neural Network -

• # node []: = larik node yang diurutkan secara topologis
• # Sisi dari a ke b berarti a di sebelah kiri b
• # Jika Jaringan Neural memiliki masukan R dan keluaran S,
• # maka node R pertama adalah node input dan node S terakhir adalah node output.
• # masuk [x]: = node terhubung ke node x
• # weight [x]: = bobot dari sisi yang masuk ke x

Untuk setiap neuron x, dari kiri ke kanan -

• jika x <= R: tidak melakukan apa pun # itu adalah simpul masukan
• masukan [x] = [keluaran [i] untuk i dalam masuk [x]]
• weighted_sum = dot_product (bobot [x], masukan [x])
• keluaran [x] = Fungsi_aktivasi (jumlah_bobot)

Sekarang kita akan belajar cara melatih jaringan saraf. Kita juga akan mempelajari algoritma propagasi mundur dan backward pass dalam Python Deep Learning.

Kita harus menemukan nilai bobot yang optimal dari jaringan saraf tiruan untuk mendapatkan keluaran yang diinginkan. Untuk melatih jaringan neural, kami menggunakan metode penurunan gradien berulang. Kami mulai awalnya dengan inisialisasi acak bobot. Setelah inisialisasi acak, kami membuat prediksi pada beberapa subset data dengan proses propagasi maju, menghitung fungsi biaya C yang sesuai, dan memperbarui setiap bobot w dengan jumlah yang sebanding dengan dC / dw, yaitu turunan dari fungsi biaya wrt bobot. Konstanta proporsionalitas dikenal sebagai kecepatan pembelajaran.

Gradien dapat dihitung secara efisien menggunakan algoritma propagasi balik. Pengamatan utama dari propagasi mundur atau prop mundur adalah bahwa karena aturan rantai diferensiasi, gradien pada setiap neuron dalam jaringan saraf dapat dihitung menggunakan gradien pada neuron, yang memiliki tepi keluar. Karenanya, kami menghitung gradien secara terbalik, yaitu, pertama-tama hitung gradien dari lapisan keluaran, kemudian lapisan paling atas yang tersembunyi, diikuti oleh lapisan tersembunyi sebelumnya, dan seterusnya, diakhiri pada lapisan masukan.

Algoritma propagasi balik diimplementasikan sebagian besar menggunakan gagasan grafik komputasi, di mana setiap neuron diperluas ke banyak node dalam grafik komputasi dan melakukan operasi matematika sederhana seperti penjumlahan, perkalian. Grafik komputasi tidak memiliki bobot di tepinya; semua bobot ditetapkan ke node, sehingga bobot menjadi node mereka sendiri. Algoritma propagasi mundur kemudian dijalankan pada grafik komputasi. Setelah penghitungan selesai, hanya gradien dari node bobot yang diperlukan untuk pembaruan. Gradien lainnya dapat dibuang.

Teknik Pengoptimalan Penurunan Gradien

Satu fungsi pengoptimalan yang umum digunakan untuk menyesuaikan bobot sesuai dengan kesalahan yang ditimbulkannya disebut "penurunan gradien".

Gradien adalah nama lain untuk kemiringan, dan kemiringan, pada grafik xy, menunjukkan bagaimana dua variabel terkait satu sama lain: kenaikan selama proses, perubahan jarak selama perubahan waktu, dll. Dalam hal ini, kemiringan adalah rasio antara kesalahan jaringan dan bobot tunggal; yaitu, bagaimana kesalahan berubah karena bobotnya bervariasi.

Lebih tepatnya, kami ingin menemukan bobot mana yang menghasilkan kesalahan paling kecil. Kami ingin menemukan bobot yang dengan benar mewakili sinyal yang terkandung dalam data masukan, dan menerjemahkannya ke klasifikasi yang benar.

Saat jaringan neural belajar, ia secara perlahan menyesuaikan banyak bobot sehingga mereka dapat memetakan sinyal ke makna dengan benar. Rasio antara Kesalahan jaringan dan masing-masing bobot tersebut merupakan turunan, dE / dw yang menghitung sejauh mana sedikit perubahan bobot menyebabkan sedikit perubahan dalam kesalahan.

Setiap bobot hanyalah satu faktor dalam jaringan dalam yang melibatkan banyak transformasi; sinyal bobot melewati aktivasi dan penjumlahan di beberapa lapisan, jadi kita menggunakan aturan rantai kalkulus untuk bekerja kembali melalui aktivasi dan keluaran jaringan. Ini membawa kita ke bobot yang dimaksud, dan hubungannya dengan kesalahan keseluruhan.

Diberikan dua variabel, kesalahan dan bobot, dimediasi oleh variabel ketiga, activation, yang dilalui beban. Kita dapat menghitung bagaimana perubahan bobot memengaruhi perubahan kesalahan dengan terlebih dahulu menghitung bagaimana perubahan aktivasi memengaruhi perubahan Kesalahan, dan bagaimana perubahan bobot memengaruhi perubahan aktivasi.

Ide dasar dalam pembelajaran mendalam tidak lebih dari itu: menyesuaikan bobot model sebagai respons atas kesalahan yang dihasilkannya, hingga Anda tidak dapat mengurangi kesalahan itu lagi.

Jaring dalam berlatih perlahan jika nilai gradien kecil dan cepat jika nilainya tinggi. Setiap ketidakakuratan dalam pelatihan menyebabkan keluaran yang tidak akurat. Proses melatih jaring dari keluaran kembali ke masukan disebut propagasi balik atau back prop. Kita tahu bahwa propagasi maju dimulai dengan input dan bekerja ke depan. Back prop melakukan kebalikan / kebalikannya menghitung gradien dari kanan ke kiri.

Setiap kali kami menghitung gradien, kami menggunakan semua gradien sebelumnya hingga titik itu.

Mari kita mulai dari sebuah simpul di lapisan keluaran. Tepi menggunakan gradien pada simpul itu. Saat kita kembali ke lapisan tersembunyi, itu menjadi lebih kompleks. Hasil perkalian dua angka antara 0 dan 1 menghasilkan angka yang lebih kecil. Nilai gradien semakin kecil dan akibatnya alat penyangga belakang membutuhkan banyak waktu untuk dilatih dan akurasi berkurang.

Tantangan dalam Algoritma Pembelajaran Mendalam

Ada tantangan tertentu untuk jaringan neural dangkal dan jaringan neural dalam, seperti overfitting dan waktu komputasi. DNN dipengaruhi oleh overfitting karena penggunaan lapisan abstraksi tambahan yang memungkinkan mereka membuat model dependensi yang jarang ada dalam data pelatihan.

Regularizationmetode seperti drop out, penghentian awal, augmentasi data, pembelajaran transfer diterapkan selama pelatihan untuk memerangi overfitting. Regularisasi pelepasan secara acak menghilangkan unit dari lapisan tersembunyi selama pelatihan, yang membantu dalam menghindari ketergantungan yang jarang terjadi. DNN mempertimbangkan beberapa parameter pelatihan seperti ukuran, yaitu jumlah lapisan dan jumlah unit per lapisan, kecepatan pembelajaran dan bobot awal. Menemukan parameter yang optimal tidak selalu praktis karena tingginya biaya waktu dan sumber daya komputasi. Beberapa peretasan seperti batching dapat mempercepat komputasi. Daya pemrosesan GPU yang besar telah secara signifikan membantu proses pelatihan, karena matriks dan komputasi vektor yang diperlukan dijalankan dengan baik di GPU.

Keluar

Putus sekolah adalah teknik regularisasi yang populer untuk jaringan saraf. Jaringan saraf dalam sangat rentan terhadap overfitting.

Sekarang mari kita lihat apa itu dropout dan bagaimana cara kerjanya.

Seperti yang dikatakan oleh Geoffrey Hinton, salah satu pelopor Deep Learning, 'Jika Anda memiliki jaringan saraf yang dalam dan tidak overfitting, Anda mungkin harus menggunakan yang lebih besar dan menggunakan dropout'.

Dropout adalah teknik di mana selama setiap iterasi penurunan gradien, kami menjatuhkan satu set node yang dipilih secara acak. Ini berarti bahwa kita mengabaikan beberapa node secara acak seolah-olah tidak ada.

Setiap neuron disimpan dengan probabilitas q dan dijatuhkan secara acak dengan probabilitas 1-q. Nilai q mungkin berbeda untuk setiap lapisan di jaringan saraf. Nilai 0,5 untuk lapisan tersembunyi, dan 0 untuk lapisan masukan berfungsi dengan baik pada berbagai tugas.

Selama evaluasi dan prediksi, tidak ada dropout yang digunakan. Keluaran tiap neuron dikalikan dengan q sehingga masukan ke lapisan berikutnya memiliki nilai yang diharapkan sama.

Ide di balik Dropout adalah sebagai berikut - Dalam jaringan saraf tanpa regularisasi dropout, neuron mengembangkan ketergantungan satu sama lain yang menyebabkan overfitting.

Trik implementasi

Pelepasan diterapkan di pustaka seperti TensorFlow dan Pytorch dengan mempertahankan keluaran neuron yang dipilih secara acak sebagai 0. Artinya, meskipun neuron tersebut ada, keluarannya ditimpa sebagai 0.

Penghentian Awal

Kami melatih jaringan neural menggunakan algoritme iteratif yang disebut penurunan gradien.

Ide di balik penghentian awal bersifat intuitif; kami menghentikan pelatihan ketika kesalahan mulai meningkat. Di sini, dengan kesalahan, yang kami maksud adalah kesalahan yang diukur pada data validasi, yang merupakan bagian dari data pelatihan yang digunakan untuk menyetel hyper-parameter. Dalam kasus ini, hyper-parameternya adalah kriteria stop.

Augmentasi Data

Proses di mana kami meningkatkan kuantum data yang kami miliki atau menambahnya dengan menggunakan data yang ada dan menerapkan beberapa transformasi padanya. Transformasi yang tepat digunakan bergantung pada tugas yang ingin kita capai. Selain itu, transformasi yang membantu jaringan saraf bergantung pada arsitekturnya.

Misalnya, dalam banyak tugas computer vision seperti klasifikasi objek, teknik augmentasi data yang efektif adalah menambahkan titik data baru yang dipotong atau diterjemahkan dari versi data asli.

Ketika komputer menerima gambar sebagai input, itu mengambil larik nilai piksel. Katakanlah seluruh gambar bergeser ke kiri sebesar 15 piksel. Kami menerapkan banyak perubahan berbeda ke arah yang berbeda, menghasilkan kumpulan data yang diperbesar berkali-kali lipat ukuran kumpulan data asli.

Transfer Pembelajaran

Proses mengambil model terlatih dan "menyempurnakan" model dengan kumpulan data kita sendiri disebut pembelajaran transfer. Ada beberapa cara untuk melakukan ini. Beberapa cara dijelaskan di bawah ini -

• Kami melatih model terlatih pada set data yang besar. Kemudian, kami menghapus lapisan terakhir jaringan dan menggantinya dengan lapisan baru dengan bobot acak.

• Kami kemudian membekukan bobot semua lapisan lainnya dan melatih jaringan secara normal. Di sini, membekukan lapisan tidak mengubah bobot selama penurunan gradien atau pengoptimalan.

Konsep di balik ini adalah bahwa model terlatih akan bertindak sebagai ekstraktor fitur, dan hanya lapisan terakhir yang akan dilatih untuk tugas saat ini.

Propagasi mundur diimplementasikan dalam framework pembelajaran mendalam seperti Tensorflow, Torch, Theano, dll., Dengan menggunakan grafik komputasi. Lebih penting lagi, memahami propagasi balik pada grafik komputasi menggabungkan beberapa algoritma yang berbeda dan variasinya seperti backprop melalui waktu dan backprop dengan bobot bersama. Setelah semuanya diubah menjadi grafik komputasi, mereka masih menggunakan algoritme yang sama - hanya propagasi balik pada grafik komputasi.

Apa itu Grafik Komputasi

Grafik komputasi didefinisikan sebagai grafik berarah di mana node sesuai dengan operasi matematika. Grafik komputasi adalah cara untuk mengekspresikan dan mengevaluasi ekspresi matematika.

Misalnya, berikut adalah persamaan matematika sederhana -

$$p = x+y$$

Kita dapat menggambar grafik komputasi dari persamaan di atas sebagai berikut.

Grafik komputasi di atas memiliki node tambahan (node ​​dengan tanda "+") dengan dua variabel input x dan y dan satu output q.

Mari kita ambil contoh lain, sedikit lebih rumit. Kami memiliki persamaan berikut.

$$g = \left (x+y \right ) \ast z $$

Persamaan di atas diwakili oleh grafik komputasi berikut.

Grafik Komputasi dan Propagasi Balik

Grafik komputasi dan propagasi mundur, keduanya merupakan konsep inti penting dalam pembelajaran mendalam untuk melatih jaringan saraf.

Lulus ke Depan

Forward pass adalah prosedur untuk mengevaluasi nilai ekspresi matematika yang diwakili oleh grafik komputasi. Melakukan forward pass berarti kita meneruskan nilai dari variabel ke arah depan dari kiri (masukan) ke kanan tempat keluarannya.

Mari kita pertimbangkan contoh dengan memberikan beberapa nilai untuk semua input. Misalkan, nilai berikut diberikan ke semua input.

$$x=1, y=3, z=−3$$

Dengan memberikan nilai-nilai ini ke input, kita dapat melakukan forward pass dan mendapatkan nilai-nilai berikut untuk output pada setiap node.

Pertama, kita gunakan nilai x = 1 dan y = 3, untuk mendapatkan p = 4.

Kemudian kami menggunakan p = 4 dan z = -3 untuk mendapatkan g = -12. Kami pergi dari kiri ke kanan, ke depan.

Tujuan Backward Pass

Pada backward pass, maksud kami adalah menghitung gradien untuk setiap masukan terkait dengan hasil akhir. Gradien ini penting untuk melatih jaringan saraf menggunakan penurunan gradien.

Misalnya, kami menginginkan gradien berikut.

Gradien yang diinginkan

$$\frac{\partial x}{\partial f}, \frac{\partial y}{\partial f}, \frac{\partial z}{\partial f}$$

Pass mundur (propagasi mundur)

Kami memulai backward pass dengan mencari turunan dari hasil akhir sehubungan dengan hasil akhir (itu sendiri!). Sehingga akan menghasilkan turunan identitas dan nilainya sama dengan satu.

$$\frac{\partial g}{\partial g} = 1$$

Grafik komputasi kami sekarang terlihat seperti yang ditunjukkan di bawah ini -

Selanjutnya, kita akan melakukan backward pass melalui operasi "*". Kami akan menghitung gradien pada p dan z. Karena g = p * z, kita tahu bahwa -

$$\frac{\partial g}{\partial z} = p$$

$$\frac{\partial g}{\partial p} = z$$

Kita sudah mengetahui nilai z dan p dari forward pass. Karenanya, kami mendapatkan -

$$\frac{\partial g}{\partial z} = p = 4$$

dan

$$\frac{\partial g}{\partial p} = z = -3$$

Kami ingin menghitung gradien pada x dan y -

$$\frac{\partial g}{\partial x}, \frac{\partial g}{\partial y}$$

Namun, kami ingin melakukan ini secara efisien (meskipun x dan g hanya berjarak dua lompatan dalam grafik ini, bayangkan keduanya sangat jauh dari satu sama lain). Untuk menghitung nilai-nilai ini secara efisien, kita akan menggunakan aturan rantai diferensiasi. Dari aturan rantai, kami memiliki -

$$\frac{\partial g}{\partial x}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial x}$$

$$\frac{\partial g}{\partial y}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial y}$$

Tapi kita sudah tahu dg / dp = -3, dp / dx dan dp / dy mudah karena p langsung bergantung pada x dan y. Kami memiliki -

$$p=x+y\Rightarrow \frac{\partial x}{\partial p} = 1, \frac{\partial y}{\partial p} = 1$$

Karenanya, kami mendapatkan -

$$\frac{\partial g} {\partial f} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial x} = \left ( -3 \right ).1 = -3$$

Selain itu, untuk input y -

$$\frac{\partial g} {\partial y} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial y} = \left ( -3 \right ).1 = -3$$

Alasan utama untuk melakukan ini secara terbalik adalah ketika kita harus menghitung gradien pada x, kita hanya menggunakan nilai yang sudah dihitung, dan dq / dx (turunan dari keluaran simpul sehubungan dengan masukan simpul yang sama). Kami menggunakan informasi lokal untuk menghitung nilai global.

Langkah-langkah untuk melatih jaringan saraf

Ikuti langkah-langkah ini untuk melatih jaringan saraf -

• Untuk titik data x dalam dataset, dilakukan forward pass dengan input x, dan menghitung biaya c sebagai output.

• Kami melakukan backward pass mulai dari c, dan menghitung gradien untuk semua node dalam grafik. Ini termasuk node yang mewakili bobot jaringan neural.

• Kami kemudian memperbarui bobot dengan melakukan gradien W = W - kecepatan pembelajaran *.

• Kami mengulangi proses ini sampai kriteria berhenti terpenuhi.

Pembelajaran mendalam telah menghasilkan hasil yang baik untuk beberapa aplikasi seperti visi komputer, terjemahan bahasa, pembuatan teks gambar, transkripsi audio, biologi molekuler, pengenalan ucapan, pemrosesan bahasa alami, mobil tanpa pengemudi, deteksi tumor otak, terjemahan ucapan waktu nyata, musik komposisi, bermain game otomatis dan sebagainya.

Pembelajaran mendalam adalah lompatan besar berikutnya setelah pembelajaran mesin dengan implementasi yang lebih canggih. Saat ini, ini sedang menuju ke standar industri yang membawa janji kuat untuk menjadi pengubah permainan ketika berurusan dengan data mentah tidak terstruktur.

Pembelajaran mendalam saat ini merupakan salah satu penyedia solusi terbaik untuk berbagai masalah dunia nyata. Pengembang sedang membangun program AI yang, alih-alih menggunakan aturan yang diberikan sebelumnya, belajar dari contoh untuk menyelesaikan tugas yang rumit. Dengan pembelajaran mendalam yang digunakan oleh banyak ilmuwan data, jaringan saraf yang lebih dalam memberikan hasil yang semakin akurat.

Idenya adalah untuk mengembangkan jaringan saraf dalam dengan meningkatkan jumlah lapisan pelatihan untuk setiap jaringan; mesin mempelajari lebih lanjut tentang data hingga seakurat mungkin. Pengembang dapat menggunakan teknik pembelajaran mendalam untuk mengimplementasikan tugas pembelajaran mesin yang kompleks, dan melatih jaringan AI untuk memiliki pengenalan persepsi tingkat tinggi.

Pembelajaran mendalam menemukan popularitasnya dalam visi Komputer. Di sini salah satu tugas yang dicapai adalah klasifikasi citra di mana citra masukan yang diberikan diklasifikasikan sebagai kucing, anjing, dll. Atau sebagai kelas atau label yang paling menggambarkan citra tersebut. Kita sebagai manusia belajar bagaimana melakukan tugas ini sejak awal dalam hidup kita dan memiliki keterampilan mengenali pola dengan cepat, menggeneralisasi dari pengetahuan sebelumnya, dan beradaptasi dengan lingkungan gambar yang berbeda.

Dalam bab ini, kita akan menghubungkan pembelajaran mendalam ke berbagai perpustakaan dan kerangka kerja.

Pembelajaran mendalam dan Theano

Jika kita ingin memulai pengkodean jaringan neural dalam, sebaiknya kita memiliki gambaran bagaimana kerangka kerja yang berbeda seperti Theano, TensorFlow, Keras, PyTorch, dll bekerja.

Theano adalah pustaka python yang menyediakan serangkaian fungsi untuk membangun jaring dalam yang melatih dengan cepat di mesin kami.

Theano dikembangkan di University of Montreal, Kanada di bawah kepemimpinan Yoshua Bengio, seorang pelopor jaringan mendalam.

Theano memungkinkan kita mendefinisikan dan mengevaluasi ekspresi matematika dengan vektor dan matriks yang merupakan susunan bilangan persegi panjang.

Secara teknis, jaringan saraf dan data masukan dapat direpresentasikan sebagai matriks dan semua operasi jaringan standar dapat didefinisikan ulang sebagai operasi matriks. Ini penting karena komputer dapat melakukan operasi matriks dengan sangat cepat.

Kita dapat memproses beberapa nilai matriks secara paralel dan jika kita membangun jaringan saraf dengan struktur dasar ini, kita dapat menggunakan satu mesin dengan GPU untuk melatih jaringan yang sangat besar dalam jangka waktu yang wajar.

Namun jika kami menggunakan Theano, kami harus membangun jaring dalam dari bawah ke atas. Perpustakaan tidak menyediakan fungsionalitas lengkap untuk membuat jenis jaringan dalam tertentu.

Sebagai gantinya, kita harus mengkodekan setiap aspek deep net seperti model, lapisan, aktivasi, metode pelatihan, dan metode khusus apa pun untuk menghentikan overfitting.

Namun, kabar baiknya adalah Theano memungkinkan pembangunan implementasi kami di atas fungsi vektorisasi yang memberi kami solusi yang sangat optimal.

Ada banyak perpustakaan lain yang memperluas fungsionalitas Theano. TensorFlow dan Keras dapat digunakan dengan Theano sebagai backend.

Deep Learning dengan TensorFlow

Googles TensorFlow adalah pustaka python. Perpustakaan ini adalah pilihan tepat untuk membangun aplikasi pembelajaran mendalam tingkat komersial.

TensorFlow berkembang dari library lain DistBelief V2 yang merupakan bagian dari Google Brain Project. Pustaka ini bertujuan untuk memperluas portabilitas pembelajaran mesin sehingga model penelitian dapat diterapkan pada aplikasi tingkat komersial.

Sama seperti pustaka Theano, TensorFlow didasarkan pada grafik komputasi di mana sebuah node merepresentasikan data persisten atau operasi matematika, dan edge mewakili aliran data antar node, yang merupakan array atau tensor multidimensi; karenanya dinamai TensorFlow

Output dari suatu operasi atau serangkaian operasi dimasukkan sebagai input ke operasi berikutnya.

Meskipun TensorFlow dirancang untuk jaringan neural, TensorFlow berfungsi dengan baik untuk jaringan lain tempat komputasi dapat dimodelkan sebagai grafik aliran data.

TensorFlow juga menggunakan beberapa fitur dari Theano seperti eliminasi umum dan sub-ekspresi, diferensiasi otomatis, variabel bersama dan simbolik.

Berbagai jenis deep net dapat dibuat menggunakan TensorFlow seperti convolutional nets, Autoencoders, RNTN, RNN, RBM, DBM / MLP, dan sebagainya.

Namun, tidak ada dukungan untuk konfigurasi hyper parameter di TensorFlow. Untuk fungsi ini, kita dapat menggunakan Keras.

Deep Learning dan Keras

Keras adalah pustaka Python andal yang mudah digunakan untuk mengembangkan dan mengevaluasi model pembelajaran mendalam.

Ini memiliki desain minimalis yang memungkinkan kita untuk membangun jaring lapis demi lapis; latih, dan jalankan.

Ini membungkus pustaka komputasi numerik yang efisien Theano dan TensorFlow serta memungkinkan kita untuk menentukan dan melatih model jaringan neural dalam beberapa baris kode pendek.

Ini adalah API jaringan neural tingkat tinggi, yang membantu memanfaatkan pembelajaran mendalam dan kecerdasan buatan secara luas. Ini berjalan di atas sejumlah pustaka tingkat yang lebih rendah termasuk TensorFlow, Theano, dan sebagainya. Kode keras bersifat portabel; kita dapat mengimplementasikan jaringan saraf di Keras menggunakan Theano atau TensorFlow sebagai bagian belakang tanpa perubahan kode.

Dalam penerapan Deep Learning ini, tujuan kami adalah untuk memprediksi penarikan atau pengadukan data nasabah pada bank tertentu - nasabah mana yang kemungkinan besar akan meninggalkan layanan bank ini. Set data yang digunakan relatif kecil dan berisi 10.000 baris dengan 14 kolom. Kami menggunakan distribusi Anaconda, dan kerangka kerja seperti Theano, TensorFlow, dan Keras. Keras dibangun di atas Tensorflow dan Theano yang berfungsi sebagai backend-nya.

# Artificial Neural Network
# Installing Theano
pip install --upgrade theano

# Installing Tensorflow
pip install –upgrade tensorflow

# Installing Keras
pip install --upgrade keras

Langkah 1: Pemrosesan awal data

In[]:

# Importing the libraries
   import numpy as np
   import matplotlib.pyplot as plt
   import pandas as pd
 
# Importing the database
   dataset = pd.read_csv('Churn_Modelling.csv')

Langkah 2

Kami membuat matriks dari fitur set data dan variabel target, yaitu kolom 14, diberi label sebagai "Keluar".

Tampilan awal data adalah seperti di bawah ini -

In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X

Keluaran

LANGKAH 3

Y

Keluaran

array([1, 0, 1, ..., 1, 1, 0], dtype = int64)

LANGKAH 4

Kami membuat analisis lebih sederhana dengan mengkodekan variabel string. Kami menggunakan fungsi ScikitLearn 'LabelEncoder' untuk secara otomatis menyandikan label yang berbeda di kolom dengan nilai antara 0 hingga n_classes-1.

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder() 
X[:,1] = labelencoder_X_1.fit_transform(X[:,1]) 
labelencoder_X_2 = LabelEncoder() 
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X

Keluaran

Pada keluaran di atas, nama negara diganti dengan 0, 1 dan 2; sedangkan pria dan wanita diganti dengan 0 dan 1.

LANGKAH 5

Labelling Encoded Data

Kami menggunakan yang sama ScikitLearn perpustakaan dan fungsi lain yang disebut OneHotEncoder untuk hanya melewatkan nomor kolom membuat variabel dummy.

onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X

Sekarang, 2 kolom pertama mewakili negara dan kolom ke-4 mewakili jenis kelamin.

Keluaran

Kami selalu membagi data kami menjadi bagian pelatihan dan pengujian; kami melatih model kami pada data pelatihan dan kemudian kami memeriksa keakuratan model pada data pengujian yang membantu dalam mengevaluasi efisiensi model.

LANGKAH 6

Kami menggunakan ScikitLearn's train_test_splitberfungsi untuk membagi data kita menjadi set pelatihan dan set pengujian. Kami mempertahankan rasio pemisahan kereta-ke-tes sebagai 80:20.

#Splitting the dataset into the Training set and the Test Set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)

Beberapa variabel memiliki nilai dalam ribuan sementara beberapa memiliki nilai dalam puluhan atau satu. Kami menskalakan data agar lebih representatif.

LANGKAH 7

Dalam kode ini, kami menyesuaikan dan mengubah data pelatihan menggunakan StandardScalerfungsi. Kami menstandarkan penskalaan kami sehingga kami menggunakan metode pas yang sama untuk mengubah / menskalakan data uji.

# Feature Scaling

fromsklearn.preprocessing import StandardScaler 
sc = StandardScaler() 
X_train = sc.fit_transform(X_train) 
X_test = sc.transform(X_test)

Keluaran

Data sekarang diskalakan dengan benar. Akhirnya, kami selesai dengan pemrosesan awal data kami. Sekarang, kita akan mulai dengan model kita.

LANGKAH 8

Kami mengimpor Modul yang diperlukan di sini. Kita membutuhkan modul Sequential untuk menginisialisasi jaringan saraf dan modul padat untuk menambahkan lapisan tersembunyi.

# Importing the Keras libraries and packages 
import keras 
from keras.models import Sequential 
from keras.layers import Dense

LANGKAH 9

Kami akan menamai model tersebut sebagai Pengklasifikasi karena tujuan kami adalah untuk mengklasifikasikan churn pelanggan. Kemudian kami menggunakan modul Sequential untuk inisialisasi.

#Initializing Neural Network 
classifier = Sequential()

LANGKAH 10

Kami menambahkan lapisan tersembunyi satu per satu menggunakan fungsi padat. Pada kode di bawah ini, kita akan melihat banyak argumen.

Parameter pertama kami adalah output_dim. Ini adalah jumlah node yang kami tambahkan ke lapisan ini.initadalah inisialisasi dari Stochastic Gradient Decent. Dalam Jaringan Neural kami menetapkan bobot untuk setiap node. Pada inisialisasi, bobot harus mendekati nol dan kami menginisialisasi bobot secara acak menggunakan fungsi seragam. Ituinput_dimparameter hanya diperlukan untuk lapisan pertama, karena model tidak mengetahui jumlah variabel masukan kita. Di sini jumlah total variabel masukan adalah 11. Pada lapisan kedua, model secara otomatis mengetahui jumlah variabel masukan dari lapisan tersembunyi pertama.

Jalankan baris kode berikut untuk menambahkan lapisan masukan dan lapisan tersembunyi pertama -

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu', input_dim = 11))

Jalankan baris kode berikut untuk menambahkan lapisan tersembunyi kedua -

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu'))

Jalankan baris kode berikut untuk menambahkan lapisan keluaran -

classifier.add(Dense(units = 1, kernel_initializer = 'uniform', 
activation = 'sigmoid'))

LANGKAH 11

Compiling the ANN

Kami telah menambahkan beberapa lapisan ke pengklasifikasi kami sampai sekarang. Kami sekarang akan mengkompilasinya menggunakancompilemetode. Argumen yang ditambahkan dalam kontrol kompilasi akhir melengkapi jaringan neural. Jadi, kita perlu berhati-hati dalam langkah ini.

Berikut penjelasan singkat dari dalil-dalil tersebut.

Argumen pertama adalah OptimizerIni adalah algoritma yang digunakan untuk menemukan set bobot yang optimal. Algoritma ini disebutStochastic Gradient Descent (SGD). Di sini kami menggunakan satu di antara beberapa jenis, yang disebut 'pengoptimal Adam'. SGD tergantung pada kerugian, jadi parameter kedua kita adalah kerugian. Jika variabel dependen kami adalah biner, kami menggunakan fungsi kerugian logaritmik yang disebut‘binary_crossentropy’, dan jika variabel dependen kami memiliki lebih dari dua kategori dalam output, maka kami menggunakan ‘categorical_crossentropy’. Kami ingin meningkatkan kinerja jaringan saraf kami berdasarkanaccuracy, jadi kami menambahkan metrics sebagai akurasi.

# Compiling Neural Network 
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

LANGKAH 12

Sejumlah kode perlu dijalankan pada langkah ini.

Memasang JST ke Set Pelatihan

Kami sekarang melatih model kami pada data pelatihan. Kami menggunakanfitmetode agar sesuai dengan model kami. Kami juga mengoptimalkan anak timbangan untuk meningkatkan efisiensi model. Untuk ini, kami harus memperbarui bobot.Batch size adalah jumlah observasi setelah kami memperbarui bobot. Epochadalah jumlah total pengulangan. Nilai ukuran batch dan epoch dipilih dengan metode trial and error.

classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)

Membuat prediksi dan mengevaluasi model

# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)

Memprediksi satu observasi baru

# Predicting a single new observation
"""Our goal is to predict if the customer with the following data will leave the bank:
Geography: Spain
Credit Score: 500
Gender: Female
Age: 40
Tenure: 3
Balance: 50000
Number of Products: 2
Has Credit Card: Yes
Is Active Member: Yes

LANGKAH 13

Predicting the test set result

Hasil prediksi akan memberikan kemungkinan pelanggan keluar dari perusahaan. Kami akan mengubah probabilitas itu menjadi biner 0 dan 1.

# Predicting the Test set results 
y_pred = classifier.predict(X_test) 
y_pred = (y_pred > 0.5)

new_prediction = classifier.predict(sc.transform
(np.array([[0.0, 0, 500, 1, 40, 3, 50000, 2, 1, 1, 40000]])))
new_prediction = (new_prediction > 0.5)

LANGKAH 14

Ini adalah langkah terakhir di mana kami mengevaluasi kinerja model kami. Kami sudah memiliki hasil asli dan dengan demikian kami dapat membuat matriks kebingungan untuk memeriksa keakuratan model kami.

Making the Confusion Matrix

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print (cm)

Keluaran

loss: 0.3384 acc: 0.8605
[ [1541 54]
[230 175] ]

Dari matriks kebingungan, Akurasi model kami dapat dihitung sebagai -

Accuracy = 1541+175/2000=0.858

We achieved 85.8% accuracy, yang mana yang bagus.

Algoritma Propagasi Maju

Di bagian ini, kita akan belajar bagaimana menulis kode untuk melakukan propagasi maju (prediksi) untuk jaringan saraf sederhana -

Setiap titik data adalah pelanggan. Input pertama adalah berapa akun yang mereka miliki, dan input kedua adalah berapa anak yang mereka miliki. Model tersebut akan memprediksi berapa banyak transaksi yang dilakukan pengguna di tahun depan.

Data masukan dimuat sebelumnya sebagai data masukan, dan bobot ada dalam kamus yang disebut bobot. Larik bobot untuk node pertama di lapisan tersembunyi berada dalam bobot ['node_0'], dan untuk node kedua di lapisan tersembunyi masing-masing dalam bobot ['node_1'].

Bobot yang dimasukkan ke dalam node keluaran tersedia dalam bobot.

Fungsi Aktivasi Linear yang Diperbaiki

Sebuah "fungsi aktivasi" adalah fungsi yang bekerja di setiap node. Ini mengubah masukan node menjadi beberapa keluaran.

Fungsi aktivasi linier yang diperbaiki (disebut ULT ) banyak digunakan di jaringan berkinerja sangat tinggi. Fungsi ini mengambil satu angka sebagai masukan, mengembalikan 0 jika masukan negatif, dan masukan sebagai keluaran jika masukan positif.

Berikut beberapa contoh -

• relu (4) = 4
• relu (-2) = 0

Kami mengisi definisi dari relu () function−

• Kami menggunakan fungsi max () untuk menghitung nilai output relu ().
• Kami menerapkan fungsi relu () ke node_0_input untuk menghitung node_0_output.
• Kami menerapkan fungsi relu () ke node_1_input untuk menghitung node_1_output.

import numpy as np
input_data = np.array([-1, 2])
weights = {
   'node_0': np.array([3, 3]),
   'node_1': np.array([1, 5]),
   'output': np.array([2, -1])
}
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = np.tanh(node_0_input)
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = np.tanh(node_1_input)
hidden_layer_output = np.array(node_0_output, node_1_output)
output =(hidden_layer_output * weights['output']).sum()
print(output)

def relu(input):
   '''Define your relu activation function here'''
   # Calculate the value for the output of the relu function: output
   output = max(input,0)
      # Return the value just calculated
   return(output)
# Calculate node 0 value: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)

# Calculate node 1 value: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)

# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])

# Calculate model output (do not apply relu)
odel_output = (hidden_layer_outputs * weights['output']).sum()
print(model_output)# Print model output

Keluaran

0.9950547536867305
-3

Menerapkan jaringan ke banyak Pengamatan / baris data

Di bagian ini, kita akan belajar bagaimana mendefinisikan sebuah fungsi yang disebut predict_with_network (). Fungsi ini akan menghasilkan prediksi untuk beberapa observasi data, diambil dari jaringan di atas yang diambil sebagai input_data. Bobot yang diberikan di jaringan di atas sedang digunakan. Definisi fungsi relu () juga digunakan.

Mari kita definisikan fungsi yang disebut predict_with_network () yang menerima dua argumen - input_data_row dan bobot - dan mengembalikan prediksi dari jaringan sebagai keluaran.

Kami menghitung nilai input dan output untuk setiap node, menyimpannya sebagai: node_0_input, node_0_output, node_1_input, dan node_1_output.

Untuk menghitung nilai input dari sebuah node, kami mengalikan array yang relevan bersama-sama dan menghitung jumlahnya.

Untuk menghitung nilai keluaran dari sebuah node, kami menerapkan fungsi relu () ke nilai input dari node tersebut. Kami menggunakan 'for loop' untuk mengulang input_data -

Kami juga menggunakan predict_with_network () untuk menghasilkan prediksi untuk setiap baris input_data - input_data_row. Kami juga menambahkan setiap prediksi ke hasil.

# Define predict_with_network()
def predict_with_network(input_data_row, weights):
   # Calculate node 0 value
   node_0_input = (input_data_row * weights['node_0']).sum()
   node_0_output = relu(node_0_input)
   
   # Calculate node 1 value
   node_1_input = (input_data_row * weights['node_1']).sum()
   node_1_output = relu(node_1_input)
   
   # Put node values into array: hidden_layer_outputs
   hidden_layer_outputs = np.array([node_0_output, node_1_output])
   
   # Calculate model output
   input_to_final_layer = (hidden_layer_outputs*weights['output']).sum()
   model_output = relu(input_to_final_layer)
# Return model output
   return(model_output)

# Create empty list to store prediction results
results = []
for input_data_row in input_data:
   # Append prediction to results
   results.append(predict_with_network(input_data_row, weights))
print(results)# Print results

Keluaran

[0, 12]

Di sini kita telah menggunakan fungsi relu di mana relu (26) = 26 dan relu (-13) = 0 dan seterusnya.

Jaringan neural multi-lapisan dalam

Di sini kami menulis kode untuk melakukan propagasi maju untuk jaringan saraf dengan dua lapisan tersembunyi. Setiap lapisan tersembunyi memiliki dua node. Data masukan telah dimuat sebelumnya sebagaiinput_data. Node di lapisan tersembunyi pertama disebut node_0_0 dan node_0_1.

Bobot mereka telah dimuat sebelumnya sebagai bobot ['node_0_0'] dan bobot ['node_0_1'].

Node di lapisan tersembunyi kedua dipanggil node_1_0 and node_1_1. Bobot mereka telah dimuat sebelumnya sebagaiweights['node_1_0'] dan weights['node_1_1'] masing-masing.

Kami kemudian membuat keluaran model dari node tersembunyi menggunakan bobot yang dimuat sebelumnya sebagai weights['output'].

Kami menghitung node_0_0_input menggunakan bobot bobotnya ['node_0_0'] dan input_data yang diberikan. Kemudian terapkan fungsi relu () untuk mendapatkan node_0_0_output.

Kami melakukan hal yang sama seperti di atas untuk node_0_1_input untuk mendapatkan node_0_1_output.

Kami menghitung node_1_0_input menggunakan bobot bobotnya ['node_1_0'] dan keluaran dari lapisan tersembunyi pertama - hidden_0_outputs. Kami kemudian menerapkan fungsi relu () untuk mendapatkan node_1_0_output.

Kami melakukan hal yang sama seperti di atas untuk node_1_1_input untuk mendapatkan node_1_1_output.

Kami menghitung model_output menggunakan bobot ['output'] dan keluaran dari larik hidden_1_outputs lapisan tersembunyi kedua. Kami tidak menerapkan fungsi relu () ke output ini.

import numpy as np
input_data = np.array([3, 5])
weights = {
   'node_0_0': np.array([2, 4]),
   'node_0_1': np.array([4, -5]),
   'node_1_0': np.array([-1, 1]),
   'node_1_1': np.array([2, 2]),
   'output': np.array([2, 7])
}
def predict_with_network(input_data):
   # Calculate node 0 in the first hidden layer
   node_0_0_input = (input_data * weights['node_0_0']).sum()
   node_0_0_output = relu(node_0_0_input)
   
   # Calculate node 1 in the first hidden layer
   node_0_1_input = (input_data*weights['node_0_1']).sum()
   node_0_1_output = relu(node_0_1_input)
   
   # Put node values into array: hidden_0_outputs
   hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
   
   # Calculate node 0 in the second hidden layer
   node_1_0_input = (hidden_0_outputs*weights['node_1_0']).sum()
   node_1_0_output = relu(node_1_0_input)
   
   # Calculate node 1 in the second hidden layer
   node_1_1_input = (hidden_0_outputs*weights['node_1_1']).sum()
   node_1_1_output = relu(node_1_1_input)
   
   # Put node values into array: hidden_1_outputs
   hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
   
   # Calculate model output: model_output
   model_output = (hidden_1_outputs*weights['output']).sum()
      # Return model_output
   return(model_output)
output = predict_with_network(input_data)
print(output)

Keluaran

364