Tutorial Pembelajaran Mendalam: Dari Perceptrons ke Deep Networks

Dalam beberapa tahun terakhir, ada kebangkitan di bidang Kecerdasan Buatan. Ini tersebar di luar dunia akademis dengan pemain besar seperti Google, Microsoft, dan Facebook membuat tim riset mereka sendiri dan membuat beberapa akuisisi yang mengesankan.

Beberapa hal ini dapat dikaitkan dengan banyaknya data mentah yang dihasilkan oleh pengguna jejaring sosial, yang sebagian besar perlu dianalisis, munculnya solusi ilmu data tingkat lanjut, serta daya komputasi murah yang tersedia melalui GPGPU.

Namun di luar fenomena ini, kebangkitan ini sebagian besar didukung oleh tren baru dalam AI, khususnya dalam pembelajaran mesin, yang dikenal sebagai “Deep Learning”. Dalam tutorial ini, saya akan memperkenalkan Anda pada konsep dan algoritme utama di balik pembelajaran mendalam, dimulai dengan unit komposisi yang paling sederhana dan membangun konsep pembelajaran mesin di Java.

(Untuk pengungkapan penuh: Saya juga penulis perpustakaan pembelajaran mendalam Java, tersedia di sini, dan contoh dalam artikel ini diimplementasikan menggunakan perpustakaan di atas. Jika Anda suka, Anda dapat mendukungnya dengan memberikannya bintang di GitHub , yang saya akan berterima kasih. Petunjuk penggunaan tersedia di beranda.)

Tutorial Tiga Puluh Detik tentang Pembelajaran Mesin

Jika Anda tidak terbiasa, lihat pengantar pembelajaran mesin ini:

Prosedur umumnya adalah sebagai berikut:

1. Kami memiliki beberapa algoritme yang memberikan beberapa contoh berlabel, katakanlah 10 gambar anjing dengan label 1 ("Anjing") dan 10 gambar benda lain dengan label 0 ("Bukan anjing")—perhatikan bahwa kami terutama menempel untuk diawasi, klasifikasi biner untuk posting ini.
2. Algoritme "belajar" untuk mengidentifikasi gambar anjing dan, ketika diberi makan gambar baru, berharap untuk menghasilkan label yang benar (1 jika itu gambar anjing, dan 0 sebaliknya).

Pengaturan ini sangat umum: data Anda dapat berupa gejala dan label penyakit Anda; atau data Anda dapat berupa gambar karakter tulisan tangan dan label Anda adalah karakter sebenarnya yang diwakilinya.

Perceptrons: Algoritma Pembelajaran Mendalam Awal

Salah satu algoritma pelatihan terawasi yang paling awal adalah perceptron, blok pembangun jaringan saraf dasar.

Katakanlah kita memiliki n titik pada bidang, berlabel '0' dan '1'. Kami diberi poin baru dan kami ingin menebak labelnya (ini mirip dengan skenario "Anjing" dan "Bukan anjing" di atas). Bagaimana kita melakukannya?

Salah satu pendekatan mungkin untuk melihat tetangga terdekat dan mengembalikan label titik itu. Tetapi cara yang sedikit lebih cerdas untuk melakukannya adalah dengan memilih garis yang paling baik memisahkan data berlabel dan menggunakannya sebagai pengklasifikasi Anda.

Dalam hal ini, setiap bagian dari data masukan akan direpresentasikan sebagai vektor x = ( x_1, x_2 ) dan fungsi kita akan menjadi seperti “'0' jika di bawah garis, '1' jika di atas”.

Untuk mewakili ini secara matematis, biarkan pemisah kita didefinisikan oleh vektor bobot w dan offset vertikal (atau bias) b . Kemudian, fungsi kita akan menggabungkan input dan bobot dengan fungsi transfer jumlah berbobot:

Hasil dari fungsi transfer ini kemudian akan dimasukkan ke dalam fungsi aktivasi untuk menghasilkan pelabelan. Dalam contoh di atas, fungsi aktivasi kami adalah batas ambang batas (misalnya, 1 jika lebih besar dari beberapa nilai):

Melatih Perceptron

Pelatihan perceptron terdiri dari memberi makan beberapa sampel pelatihan dan menghitung output untuk masing-masing. Setelah setiap sampel, bobot w disesuaikan sedemikian rupa untuk meminimalkan kesalahan keluaran , yang didefinisikan sebagai perbedaan antara yang diinginkan (target) dan keluaran yang sebenarnya . Ada fungsi kesalahan lain, seperti kesalahan kuadrat rata-rata, tetapi prinsip dasar pelatihan tetap sama.

Kekurangan Perceptron Tunggal

Pendekatan perceptron tunggal untuk pembelajaran mendalam memiliki satu kelemahan utama: hanya dapat mempelajari fungsi yang dapat dipisahkan secara linier. Seberapa besar kelemahan ini? Ambil XOR, fungsi yang relatif sederhana, dan perhatikan bahwa itu tidak dapat diklasifikasikan oleh pemisah linier (perhatikan upaya yang gagal, di bawah):

Untuk mengatasi masalah ini, kita perlu menggunakan multilayer perceptron, juga dikenal sebagai feedforward neural network: pada dasarnya, kita akan menyusun sekelompok perceptron ini bersama-sama untuk menciptakan mekanisme pembelajaran yang lebih kuat.

Jaringan Neural Feedforward untuk Pembelajaran Mendalam

Jaringan saraf benar-benar hanya komposisi perceptron, terhubung dengan cara yang berbeda dan beroperasi pada fungsi aktivasi yang berbeda.

Sebagai permulaan, kita akan melihat jaringan saraf feedforward, yang memiliki properti berikut:

• Input, output, dan satu atau lebih lapisan tersembunyi . Gambar di atas menunjukkan jaringan dengan lapisan input 3 unit, lapisan tersembunyi 4 unit, dan lapisan output dengan 2 unit (istilah unit dan neuron dapat dipertukarkan).
• Setiap unit adalah perceptron tunggal seperti yang dijelaskan di atas.
• Unit-unit lapisan input berfungsi sebagai input untuk unit-unit lapisan tersembunyi, sedangkan unit-unit lapisan tersembunyi adalah input ke lapisan output.
• Setiap koneksi antara dua neuron memiliki bobot w (mirip dengan bobot perceptron).
• Setiap unit lapisan t biasanya terhubung ke setiap unit lapisan sebelumnya t - 1 (walaupun Anda dapat memutuskannya dengan mengatur bobotnya ke 0).
• Untuk memproses data input, Anda "menjepit" vektor input ke lapisan input, menetapkan nilai vektor sebagai "output" untuk setiap unit input. Dalam kasus khusus ini, jaringan dapat memproses vektor input 3 dimensi (karena 3 unit input). Misalnya, jika vektor input Anda adalah [7, 1, 2], maka Anda akan mengatur output dari unit input atas ke 7, unit tengah ke 1, dan seterusnya. Nilai-nilai ini kemudian disebarkan ke depan ke unit tersembunyi menggunakan fungsi transfer jumlah tertimbang untuk setiap unit tersembunyi (oleh karena itu istilah perambatan maju), yang pada gilirannya menghitung outputnya (fungsi aktivasi).
• Lapisan keluaran menghitung keluarannya dengan cara yang sama seperti lapisan tersembunyi. Hasil dari output layer adalah output dari jaringan.

Melampaui Linieritas

Bagaimana jika masing-masing perceptron kita hanya diperbolehkan menggunakan fungsi aktivasi linier? Kemudian, keluaran akhir dari jaringan kita akan tetap berupa beberapa fungsi linier dari masukan, hanya disesuaikan dengan satu ton bobot berbeda yang dikumpulkan di seluruh jaringan. Dengan kata lain, komposisi linier dari sekelompok fungsi linier masih merupakan fungsi linier. Jika kita dibatasi pada fungsi aktivasi linier, maka jaringan saraf feedforward tidak lebih kuat dari perceptron, tidak peduli berapa banyak lapisan yang dimilikinya.

Karena itu, sebagian besar jaringan saraf menggunakan fungsi aktivasi non-linier seperti logistik, tanh, biner, atau penyearah. Tanpa mereka, jaringan hanya dapat mempelajari fungsi yang merupakan kombinasi linier dari inputnya.

Pelatihan Perceptron

Algoritme pembelajaran mendalam yang paling umum untuk pelatihan terawasi dari perceptron multilayer dikenal sebagai backpropagation. Prosedur dasar:

1. Sampel pelatihan disajikan dan disebarkan ke depan melalui jaringan.

2. Kesalahan keluaran dihitung, biasanya kesalahan kuadrat rata-rata:

   Dimana t adalah nilai target dan y adalah output jaringan yang sebenarnya. Perhitungan kesalahan lainnya juga dapat diterima, tetapi MSE adalah pilihan yang baik.

3. Kesalahan jaringan diminimalkan dengan menggunakan metode yang disebut penurunan gradien stokastik.

   Penurunan gradien bersifat universal, tetapi dalam kasus jaringan saraf, ini akan menjadi grafik kesalahan pelatihan sebagai fungsi dari parameter input. Nilai optimal untuk setiap bobot adalah di mana kesalahan mencapai minimum global . Selama fase pelatihan, bobot diperbarui dalam langkah-langkah kecil (setelah setiap sampel pelatihan atau batch mini dari beberapa sampel) sedemikian rupa sehingga mereka selalu berusaha mencapai minimum global—tetapi ini bukanlah tugas yang mudah, karena Anda sering berakhir di minima lokal, seperti yang di sebelah kanan. Misalnya, jika bobot memiliki nilai 0,6, maka perlu diubah ke 0,4.

   Angka ini mewakili kasus paling sederhana, di mana kesalahan bergantung pada satu parameter. Namun, kesalahan jaringan tergantung pada setiap bobot jaringan dan fungsi kesalahannya jauh lebih kompleks.

   Untungnya, backpropagation menyediakan metode untuk memperbarui setiap bobot antara dua neuron sehubungan dengan kesalahan keluaran. Derivasi itu sendiri cukup rumit, tetapi pembaruan bobot untuk node yang diberikan memiliki bentuk (sederhana) berikut:

   Dimana E adalah output error, dan w_i adalah bobot input i ke neuron.

   Pada dasarnya, tujuannya adalah untuk bergerak ke arah gradien sehubungan dengan berat i . Istilah kuncinya adalah, tentu saja, turunan dari kesalahan, yang tidak selalu mudah untuk dihitung: bagaimana Anda menemukan turunan ini untuk bobot acak dari simpul tersembunyi acak di tengah jaringan besar?

   Jawabannya: melalui backpropagation. Kesalahan pertama kali dihitung pada unit keluaran di mana rumusnya cukup sederhana (berdasarkan perbedaan antara target dan nilai yang diprediksi), dan kemudian disebarkan kembali melalui jaringan dengan cara yang cerdas, memungkinkan kami untuk memperbarui bobot kami secara efisien selama pelatihan dan (semoga) mencapai minimum.

Lapisan Tersembunyi

Lapisan tersembunyi sangat menarik. Dengan teorema pendekatan universal, jaringan lapisan tersembunyi tunggal dengan jumlah neuron yang terbatas dapat dilatih untuk mendekati fungsi acak sewenang-wenang. Dengan kata lain, satu lapisan tersembunyi cukup kuat untuk mempelajari fungsi apa pun . Karena itu, kita sering belajar lebih baik dalam praktik dengan banyak lapisan tersembunyi (yaitu, jaring yang lebih dalam).

Lapisan tersembunyi adalah tempat jaringan menyimpan representasi abstrak internal dari data pelatihan, mirip dengan cara otak manusia (analogi yang sangat disederhanakan) memiliki representasi internal dari dunia nyata. Ke depan dalam tutorial, kita akan melihat berbagai cara untuk bermain-main dengan lapisan tersembunyi.

Contoh Jaringan

Anda dapat melihat jaringan saraf feedforward sederhana (4-2-3 layer) yang mengklasifikasikan dataset IRIS yang diimplementasikan di Java di sini melalui metode testMLPSigmoidBP . Dataset berisi tiga kelas tanaman iris dengan fitur seperti panjang sepal, panjang kelopak, dll. Jaringan disediakan 50 sampel per kelas. Fitur dijepit ke unit input, sementara setiap unit output sesuai dengan satu kelas dari dataset: "1/0/0" menunjukkan bahwa pabrik adalah kelas Setosa, "0/1/0" menunjukkan Versicolour, dan " 0/0/1" menunjukkan Virginica). Kesalahan klasifikasi adalah 2/150 (yaitu, salah mengklasifikasikan 2 sampel dari 150).

Masalah dengan Jaringan Besar

Jaringan saraf dapat memiliki lebih dari satu lapisan tersembunyi: dalam hal ini, lapisan yang lebih tinggi "membangun" abstraksi baru di atas lapisan sebelumnya. Dan seperti yang kami sebutkan sebelumnya, Anda sering dapat belajar lebih baik dalam praktik dengan jaringan yang lebih besar.

Namun, meningkatkan jumlah lapisan tersembunyi menyebabkan dua masalah yang diketahui:

1. Gradien menghilang: saat kita menambahkan lebih banyak dan lebih banyak lapisan tersembunyi, propagasi balik menjadi semakin tidak berguna dalam meneruskan informasi ke lapisan bawah. Akibatnya, saat informasi dilewatkan kembali, gradien mulai menghilang dan menjadi relatif kecil terhadap bobot jaringan.
2. Overfitting: mungkin masalah utama dalam pembelajaran mesin. Secara singkat, overfitting menggambarkan fenomena menyesuaikan data pelatihan terlalu dekat, mungkin dengan hipotesis yang terlalu kompleks. Dalam kasus seperti itu, pelajar Anda akhirnya menyesuaikan data pelatihan dengan sangat baik, tetapi akan berkinerja jauh, jauh lebih buruk pada contoh nyata.

Mari kita lihat beberapa algoritma pembelajaran mendalam untuk mengatasi masalah ini.

Autoencoder

Sebagian besar kelas pembelajaran mesin pengantar cenderung berhenti dengan jaringan saraf feedforward. Tapi ruang jaring yang mungkin jauh lebih kaya—jadi mari kita lanjutkan.

Autoencoder biasanya adalah jaringan saraf feedforward yang bertujuan untuk mempelajari representasi terkompresi dan terdistribusi (encoding) dari kumpulan data.

Secara konseptual, jaringan dilatih untuk "menciptakan kembali" input, yaitu input dan data target adalah sama. Dengan kata lain: Anda mencoba mengeluarkan hal yang sama dengan yang Anda masukkan, tetapi dikompresi dengan cara tertentu. Ini adalah pendekatan yang membingungkan, jadi mari kita lihat sebuah contoh.

Mengompresi Input: Gambar Skala Abu-Abu

Katakanlah bahwa data pelatihan terdiri dari 28x28 gambar skala abu-abu dan nilai setiap piksel dijepit ke satu neuron lapisan input (yaitu, lapisan input akan memiliki 784 neuron). Kemudian, lapisan keluaran akan memiliki jumlah unit yang sama (784) seperti lapisan masukan dan nilai target untuk setiap unit keluaran akan menjadi nilai skala abu-abu dari satu piksel gambar.

Intuisi di balik arsitektur ini adalah bahwa jaringan tidak akan mempelajari "pemetaan" antara data pelatihan dan labelnya, melainkan akan mempelajari struktur internal dan fitur data itu sendiri. (Karena itu, lapisan tersembunyi juga disebut pendeteksi fitur .) Biasanya, jumlah unit tersembunyi lebih kecil daripada lapisan input/output, yang memaksa jaringan untuk mempelajari hanya fitur yang paling penting dan mencapai pengurangan dimensi.

Akibatnya, kami ingin beberapa node kecil di tengah untuk benar-benar mempelajari data pada tingkat konseptual, menghasilkan representasi kompak yang dalam beberapa cara menangkap fitur inti dari input kami.

penyakit flu

Untuk mendemonstrasikan autoencoder lebih lanjut, mari kita lihat satu aplikasi lagi.

Dalam hal ini, kami akan menggunakan kumpulan data sederhana yang terdiri dari gejala flu (kredit ke posting blog ini untuk idenya). Jika Anda tertarik, kode untuk contoh ini dapat ditemukan di metode testAEBackpropagation .

Berikut adalah cara kumpulan data rusak:

• Ada enam fitur input biner.
• Tiga yang pertama adalah gejala penyakit. Misalnya, 1 0 0 0 0 0 menunjukkan bahwa pasien ini memiliki suhu tinggi, sedangkan 0 1 0 0 0 0 menunjukkan batuk, 1 1 0 0 0 0 menunjukkan batuk dan suhu tinggi, dll.
• Tiga fitur terakhir adalah gejala "kontra"; ketika seorang pasien memiliki salah satu dari ini, kecil kemungkinannya dia sakit. Misalnya, 0 0 0 1 0 0 menunjukkan bahwa pasien ini memiliki vaksin flu. Dimungkinkan untuk memiliki kombinasi dari dua set fitur: 0 1 0 1 0 0 menunjukkan pasien vaksin dengan batuk, dan sebagainya.

Kami akan menganggap seorang pasien sakit ketika dia memiliki setidaknya dua dari tiga fitur pertama dan sehat jika dia memiliki setidaknya dua dari tiga fitur kedua (dengan pemutusan ikatan demi pasien yang sehat), misalnya:

• 111000, 101000, 110000, 011000, 011100 = sakit
• 000111, 001110, 000101, 000011, 000110 = sehat

Kami akan melatih autoencoder (menggunakan backpropagation) dengan enam unit input dan enam output, tetapi hanya dua unit tersembunyi .

Setelah beberapa ratus iterasi, kami mengamati bahwa ketika masing-masing sampel "sakit" disajikan ke jaringan pembelajaran mesin, salah satu dari dua unit tersembunyi (unit yang sama untuk setiap sampel "sakit") selalu menunjukkan nilai aktivasi yang lebih tinggi daripada lainnya. Sebaliknya, ketika sampel "sehat" disajikan, unit tersembunyi lainnya memiliki aktivasi yang lebih tinggi.

Kembali ke Pembelajaran Mesin

Pada dasarnya, dua unit tersembunyi kami telah mempelajari representasi ringkas dari kumpulan data gejala flu. Untuk melihat bagaimana hal ini berhubungan dengan pembelajaran, kita kembali ke masalah overfitting. Dengan melatih jaring kami untuk mempelajari representasi data yang ringkas, kami lebih menyukai representasi yang lebih sederhana daripada hipotesis yang sangat kompleks yang melebihi data pelatihan.

Di satu sisi, dengan menyukai representasi yang lebih sederhana ini, kami mencoba mempelajari data dalam arti yang lebih benar.

Mesin Boltzmann Terbatas

Langkah logis berikutnya adalah melihat mesin Restricted Boltzmann (RBM), sebuah jaringan saraf stokastik generatif yang dapat mempelajari distribusi probabilitas pada kumpulan inputnya .

RBM terdiri dari lapisan tersembunyi, terlihat, dan bias. Tidak seperti jaringan feedforward, koneksi antara lapisan terlihat dan lapisan tersembunyi tidak terarah (nilai dapat disebarkan baik dalam arah yang terlihat-ke-tersembunyi dan tersembunyi-ke-terlihat) dan terhubung penuh (setiap unit dari lapisan tertentu terhubung ke setiap unit di berikutnya—jika kami mengizinkan unit apa pun di lapisan mana pun untuk terhubung ke lapisan lain, maka kami akan memiliki mesin Boltzmann (bukan Boltzmann ) yang dibatasi ).

RBM standar memiliki unit biner tersembunyi dan terlihat: yaitu, aktivasi unit adalah 0 atau 1 di bawah distribusi Bernoulli, tetapi ada varian dengan non-linier lainnya.

Sementara para peneliti telah mengetahui tentang RBM untuk beberapa waktu sekarang, pengenalan baru-baru ini tentang algoritma pelatihan tanpa pengawasan divergensi kontrastif telah memperbaharui minat.

Divergensi Kontrastif

Algoritma divergensi kontrastif satu langkah (CD-1) bekerja seperti ini:

1. fase positif :
   • Sampel input v dijepit ke lapisan input.
   • v disebarkan ke lapisan tersembunyi dengan cara yang mirip dengan jaringan feedforward. Hasil aktivasi lapisan tersembunyi adalah h .
2. fase negatif :
   • Sebarkan h kembali ke lapisan yang terlihat dengan hasil v' (koneksi antara lapisan yang terlihat dan tersembunyi tidak terarah dan dengan demikian memungkinkan gerakan di kedua arah).
   • Sebarkan v' baru kembali ke lapisan tersembunyi dengan hasil aktivasi h' .

3. Pembaruan berat :

   Dimana a adalah kecepatan belajar dan v , v' , h , h' , dan w adalah vektor.

Intuisi di balik algoritme adalah bahwa fase positif ( h diberikan v ) mencerminkan representasi internal jaringan dari data dunia nyata . Sedangkan fase negatif merupakan upaya untuk membuat ulang data berdasarkan representasi internal ini ( v' diberikan h ). Tujuan utamanya adalah agar data yang dihasilkan sedekat mungkin dengan dunia nyata dan ini tercermin dalam formula pembaruan bobot.

Dengan kata lain, jaring memiliki beberapa persepsi tentang bagaimana data masukan dapat direpresentasikan, sehingga ia mencoba untuk mereproduksi data berdasarkan persepsi ini. Jika reproduksinya tidak cukup dekat dengan kenyataan, ia membuat penyesuaian dan mencoba lagi.

Kembali ke Flu

Untuk mendemonstrasikan divergensi kontrastif, kita akan menggunakan kumpulan data gejala yang sama seperti sebelumnya. Jaringan uji adalah RBM dengan enam unit yang terlihat dan dua unit yang tersembunyi. Kami akan melatih jaringan menggunakan divergensi kontras dengan gejala v dijepit ke lapisan yang terlihat. Selama pengujian, gejala kembali ditampilkan ke lapisan yang terlihat; kemudian, data disebarkan ke lapisan tersembunyi. Unit tersembunyi mewakili keadaan sakit/sehat, arsitektur yang sangat mirip dengan autoencoder (menyebarkan data dari yang terlihat ke lapisan tersembunyi).

Setelah beberapa ratus iterasi, kita dapat mengamati hasil yang sama dengan autoencoder: salah satu unit tersembunyi memiliki nilai aktivasi yang lebih tinggi ketika salah satu sampel "sakit" ditampilkan, sementara yang lain selalu lebih aktif untuk sampel "sehat".

Anda dapat melihat contoh ini beraksi dalam metode testContrastiveDivergence .

Jaringan Dalam

Kami sekarang telah menunjukkan bahwa lapisan tersembunyi autoencoder dan RBM bertindak sebagai pendeteksi fitur yang efektif; tapi jarang kita bisa menggunakan fitur ini secara langsung. Faktanya, kumpulan data di atas lebih merupakan pengecualian daripada aturan. Sebaliknya, kita perlu menemukan cara untuk menggunakan fitur yang terdeteksi ini secara tidak langsung.

Untungnya, ditemukan bahwa struktur ini dapat ditumpuk untuk membentuk jaringan yang dalam . Jaringan ini dapat dilatih dengan rakus, satu lapis pada satu waktu, untuk membantu mengatasi gradien yang hilang dan masalah overfitting yang terkait dengan backpropagation klasik.

Struktur yang dihasilkan seringkali cukup kuat, menghasilkan hasil yang mengesankan. Ambil contoh, makalah "kucing" Google yang terkenal di mana mereka menggunakan jenis khusus autoencoder mendalam untuk "mempelajari" deteksi wajah manusia dan kucing berdasarkan data yang tidak berlabel .

Mari kita lihat lebih dekat.

Autoencoder bertumpuk

Seperti namanya, jaringan ini terdiri dari beberapa autoencoder bertumpuk.

Lapisan tersembunyi autoencoder t bertindak sebagai lapisan input ke autoencoder t + 1 . Lapisan input dari autoencoder pertama adalah lapisan input untuk seluruh jaringan. Prosedur pelatihan serakah lapisan-bijaksana bekerja seperti ini:

1. Latih autoencoder pertama ( t=1 , atau koneksi merah pada gambar di atas, tetapi dengan lapisan output tambahan) satu per satu menggunakan metode backpropagation dengan semua data pelatihan yang tersedia.
2. Latih autoencoder kedua t=2 (koneksi hijau). Karena lapisan masukan untuk t=2 adalah lapisan tersembunyi dari t=1 , kami tidak lagi tertarik pada lapisan keluaran t=1 dan kami menghapusnya dari jaringan. Pelatihan dimulai dengan menjepit sampel input ke lapisan input t=1 , yang disebarkan ke depan ke lapisan output t=2 . Selanjutnya, bobot (input-hidden dan hidden-output) dari t=2 diupdate menggunakan backpropagation. t=2 menggunakan semua sampel pelatihan, mirip dengan t=1 .
3. Ulangi prosedur sebelumnya untuk semua lapisan (yaitu, hapus lapisan keluaran dari autoencoder sebelumnya, ganti dengan autoencoder lain, dan latih dengan propagasi balik).
4. Langkah 1-3 disebut pra-pelatihan dan biarkan bobot diinisialisasi dengan benar. Namun, tidak ada pemetaan antara data input dan label output. Misalnya, jika jaringan dilatih untuk mengenali gambar digit tulisan tangan, masih tidak mungkin untuk memetakan unit dari detektor fitur terakhir (yaitu, lapisan tersembunyi dari autoencoder terakhir) ke jenis digit gambar. Dalam hal ini, solusi paling umum adalah menambahkan satu atau lebih lapisan yang terhubung penuh ke lapisan terakhir (koneksi biru). Seluruh jaringan sekarang dapat dilihat sebagai perceptron multilayer dan dilatih menggunakan backpropagation (langkah ini juga disebut fine-tuning ).

Oleh karena itu, pembuat enkode otomatis bertumpuk adalah tentang menyediakan metode pra-pelatihan yang efektif untuk menginisialisasi bobot jaringan, sehingga Anda memiliki perceptron multi-lapisan yang kompleks yang siap untuk dilatih (atau disempurnakan ).

Jaringan Kepercayaan Mendalam

Seperti halnya autoencoder, kami juga dapat menumpuk mesin Boltzmann untuk membuat kelas yang dikenal sebagai deep belief networks (DBNs) .

Dalam hal ini, lapisan tersembunyi RBM t bertindak sebagai lapisan tampak untuk RBM t+1 . Lapisan input dari RBM pertama adalah lapisan input untuk seluruh jaringan, dan pra-pelatihan untuk lapisan serakah bekerja seperti ini:

1. Latih RBM pertama t=1 menggunakan divergensi kontrastif dengan semua sampel pelatihan.
2. Latih RBM kedua t=2 . Karena lapisan tampak untuk t=2 adalah lapisan tersembunyi t=1 , pelatihan dimulai dengan menjepit sampel input ke lapisan tampak t=1 , yang disebarkan ke depan ke lapisan tersembunyi t=1 . Data ini kemudian berfungsi untuk memulai pelatihan divergensi kontrastif untuk t=2 .
3. Ulangi prosedur sebelumnya untuk semua lapisan.
4. Mirip dengan autoencoder bertumpuk, setelah pra-pelatihan jaringan dapat diperluas dengan menghubungkan satu atau lebih lapisan yang terhubung penuh ke lapisan tersembunyi RBM akhir. Ini membentuk perceptron multi-layer yang kemudian dapat disetel dengan baik menggunakan backpropagation.

Prosedur ini mirip dengan autoencoder bertumpuk, tetapi dengan autoencoder digantikan oleh RBM dan backpropagation diganti dengan algoritma divergensi kontrastif.

(Catatan: untuk mengetahui lebih lanjut tentang membangun dan melatih autoencoder bertumpuk atau jaringan kepercayaan mendalam, lihat kode contoh di sini.)

Jaringan Konvolusi

Sebagai arsitektur pembelajaran mendalam terakhir, mari kita lihat jaringan convolutional, kelas jaringan feedforward yang sangat menarik dan khusus yang sangat cocok untuk pengenalan gambar.

Sebelum kita melihat struktur sebenarnya dari jaringan konvolusi, pertama-tama kita mendefinisikan filter gambar , atau wilayah persegi dengan bobot terkait. Filter diterapkan di seluruh gambar input, dan Anda akan sering menerapkan beberapa filter. Misalnya, Anda dapat menerapkan empat filter 6x6 ke gambar input yang diberikan. Kemudian, piksel keluaran dengan koordinat 1,1 adalah jumlah bobot dari piksel masukan 6x6 persegi dengan sudut kiri atas 1,1 dan bobot filter (yang juga berukuran 6x6 persegi). Piksel keluaran 2,1 merupakan hasil dari kotak masukan dengan sudut kiri atas 2,1 dan seterusnya.

Dengan itu, jaringan ini ditentukan oleh properti berikut:

• Lapisan convolutional menerapkan sejumlah filter ke input. Misalnya, lapisan konvolusi pertama dari gambar dapat memiliki empat filter 6x6. Hasil dari satu filter yang diterapkan di seluruh gambar disebut peta fitur (FM) dan jumlah peta fitur sama dengan jumlah filter. Jika lapisan sebelumnya juga konvolusi, filter diterapkan di semua FM-nya dengan bobot yang berbeda, sehingga setiap FM input terhubung ke setiap FM keluaran. Intuisi di balik bobot bersama di seluruh gambar adalah bahwa fitur akan terdeteksi terlepas dari lokasinya, sementara banyaknya filter memungkinkan masing-masing fitur mendeteksi rangkaian fitur yang berbeda.
• Lapisan subsampling mengurangi ukuran input. Misalnya, jika input terdiri dari gambar 32x32 dan lapisan memiliki wilayah subsampling 2x2, nilai outputnya adalah gambar 16x16, yang berarti bahwa 4 piksel (masing-masing 2x2 persegi) dari gambar input digabungkan menjadi satu output piksel. Ada beberapa cara untuk subsampel, tapi yang paling populer adalah max pooling, average pooling, dan stochastic pooling.
• Lapisan subsampling (atau convolutional) terakhir biasanya terhubung ke satu atau lebih lapisan yang terhubung sepenuhnya, yang terakhir mewakili data target.
• Pelatihan dilakukan menggunakan propagasi balik yang dimodifikasi yang memperhitungkan lapisan subsampling dan memperbarui bobot filter konvolusi berdasarkan semua nilai yang diterapkan filter tersebut.

Anda dapat melihat beberapa contoh jaringan konvolusi yang dilatih (dengan propagasi balik) pada kumpulan data MNIST (gambar skala abu-abu dari huruf tulisan tangan) di sini, khususnya dalam metode testLeNet* (saya akan merekomendasikan testLeNetTiny2 karena tingkat kesalahannya rendah sekitar 2% dalam waktu yang relatif singkat). Ada juga visualisasi JavaScript yang bagus dari jaringan serupa di sini.

Penerapan

Sekarang setelah kita membahas varian jaringan saraf yang paling umum, saya pikir saya akan menulis sedikit tentang tantangan yang ditimbulkan selama penerapan struktur pembelajaran mendalam ini.

Secara umum, tujuan saya dalam membuat perpustakaan Deep Learning adalah (dan masih) untuk membangun kerangka kerja berbasis jaringan saraf yang memenuhi kriteria berikut:

• Arsitektur umum yang mampu mewakili model yang beragam (semua varian pada jaringan saraf yang telah kita lihat di atas, misalnya).
• Kemampuan untuk menggunakan algoritma pelatihan yang beragam (propagasi balik, divergensi kontrastif, dll.).
• Kinerja yang layak.

Untuk memenuhi persyaratan ini, saya mengambil pendekatan berjenjang (atau modular) untuk desain perangkat lunak.

Struktur

Mari kita mulai dengan dasar-dasarnya:

• NeuralNetworkImpl adalah kelas dasar untuk semua model jaringan saraf.
• Setiap jaringan berisi satu set lapisan.
• Setiap lapisan memiliki daftar koneksi, di mana koneksi adalah tautan antara dua lapisan sedemikian rupa sehingga jaringannya adalah grafik asiklik berarah.

Struktur ini cukup gesit untuk digunakan untuk jaringan feedforward klasik, serta untuk RBM dan arsitektur yang lebih kompleks seperti ImageNet.

Hal ini juga memungkinkan lapisan untuk menjadi bagian dari lebih dari satu jaringan. Misalnya, lapisan dalam Jaringan Kepercayaan Dalam juga merupakan lapisan dalam RBM yang sesuai.

Selain itu, arsitektur ini memungkinkan DBN untuk dilihat sebagai daftar RBM yang ditumpuk selama fase pra-pelatihan dan jaringan feedforward selama fase fine-tuning, yang secara intuitif bagus dan nyaman secara program.

Propagasi Data

Modul berikutnya menangani penyebaran data melalui jaringan, proses dua langkah:

1. Tentukan urutan lapisannya. Misalnya, untuk mendapatkan hasil dari perceptron multilayer, data "dijepit" ke lapisan input (oleh karena itu, ini adalah lapisan pertama yang dihitung) dan disebarkan sampai ke lapisan output. Untuk memperbarui bobot selama backpropagation, kesalahan output harus disebarkan melalui setiap lapisan dalam urutan pertama, mulai dari lapisan output. Ini dicapai dengan menggunakan berbagai implementasi LayerOrderStrategy , yang memanfaatkan struktur grafik jaringan, menggunakan metode traversal grafik yang berbeda. Beberapa contoh termasuk strategi luas-pertama dan penargetan lapisan tertentu. Urutan sebenarnya ditentukan oleh koneksi antar lapisan, sehingga strategi mengembalikan daftar koneksi yang dipesan.
2. Hitung nilai aktivasi. Setiap lapisan memiliki ConnectionCalculator terkait yang mengambil daftar koneksinya (dari langkah sebelumnya) dan nilai input (dari lapisan lain) dan menghitung aktivasi yang dihasilkan. Misalnya, dalam jaringan umpan maju sigmoidal sederhana, ConnectionCalculator lapisan tersembunyi mengambil nilai dari lapisan input dan bias (yang masing-masing adalah data input dan larik 1s ) dan bobot antara unit (dalam kasus terhubung penuh lapisan, bobot sebenarnya disimpan dalam koneksi FullyConnected sebagai Matriks ), menghitung jumlah bobot, dan memasukkan hasilnya ke dalam fungsi sigmoid. Kalkulator koneksi mengimplementasikan berbagai fungsi transfer (misalnya, jumlah tertimbang, konvolusi) dan aktivasi (misalnya, logistik dan tanh untuk multilayer perceptron, biner untuk RBM). Kebanyakan dari mereka dapat dieksekusi pada GPU menggunakan Aparapi dan dapat digunakan dengan pelatihan mini-batch.

Komputasi GPU dengan Aparapi

Seperti yang saya sebutkan sebelumnya, salah satu alasan mengapa jaringan saraf muncul kembali dalam beberapa tahun terakhir adalah bahwa metode pelatihan mereka sangat kondusif untuk paralelisme, memungkinkan Anda untuk mempercepat pelatihan secara signifikan dengan penggunaan GPGPU. Dalam hal ini, saya memilih untuk bekerja dengan perpustakaan Aparapi untuk menambahkan dukungan GPU.

Aparapi memberlakukan beberapa batasan penting pada kalkulator koneksi:

• Hanya array satu dimensi (dan variabel) dari tipe data primitif yang diizinkan.
• Hanya metode anggota dari kelas Kernel Aparapi itu sendiri yang diizinkan untuk dipanggil dari kode yang dapat dieksekusi GPU.

Dengan demikian, sebagian besar data (bobot, array input, dan output) disimpan dalam instance Matrix , yang menggunakan array float satu dimensi secara internal. Semua kalkulator koneksi Aparapi menggunakan AparapiWeightedSum (untuk layer yang terhubung penuh dan fungsi input penjumlahan berbobot), AparapiSubsampling2D (untuk layer subsampling), atau AparapiConv2D (untuk layer convolutional). Beberapa keterbatasan ini dapat diatasi dengan pengenalan Arsitektur Sistem Heterogen. Aparapi also allows to run the same code on both CPU and GPU.

Pelatihan

The training module implements various training algorithms. It relies on the previous two modules. For example, BackPropagationTrainer (all the trainers are using the Trainer base class) uses feedforward layer calculator for the feedforward phase and a special breadth-first layer calculator for propagating the error and updating the weights.

My latest work is on Java 8 support and some other improvements, will soon be merged into master.

Conclusion

The aim of this Java deep learning tutorial was to give you a brief introduction to the field of deep learning algorithms, beginning with the most basic unit of composition (the perceptron) and progressing through various effective and popular architectures, like that of the restricted Boltzmann machine.

The ideas behind neural networks have been around for a long time; but today, you can't step foot in the machine learning community without hearing about deep networks or some other take on deep learning. Hype shouldn't be mistaken for justification, but with the advances of GPGPU computing and the impressive progress made by researchers like Geoffrey Hinton, Yoshua Bengio, Yann LeCun and Andrew Ng, the field certainly shows a lot of promise. There's no better time to get familiar and get involved like the present.

Appendix: Resources

If you're interested in learning more, I found the following resources quite helpful during my work:

• DeepLearning.net: a portal for all things deep learning. It has some nice tutorials, software library and a great reading list.
• An active Google+ community.
• Two very good courses: Machine Learning and Neural Networks for Machine Learning, both offered on Coursera.
• The Stanford neural networks tutorial.