Untuk pembelajaran mendalam yang populer sekarang, perlu untuk mempertahankan semangat pembelajaran - pemrogram, terutama arsitek, harus selalu peduli tentang teknologi inti dan algoritma utama, dan bila perlu, Anda harus menulis dan menguasainya. Tidak peduli kapan harus menggunakannya - apakah akan menggunakannya adalah masalah politik atau apakah akan menulisnya adalah masalah teknis, seperti halnya tentara tidak peduli apakah akan bertarung atau tidak, tetapi tentang cara menang.
Bagaimana programmer belajar pembelajaran mesin
Untuk pemrogram, pembelajaran mesin memiliki ambang batas tertentu (ambang ini juga merupakan daya saing intinya). Saya percaya bahwa banyak orang akan mengalami sakit kepala untuk makalah bahasa Inggris yang penuh dengan formula matematika ketika belajar belajar mesin, dan bahkan mungkin menyerah. Namun pada kenyataannya, program implementasi algoritma pembelajaran mesin tidak sulit untuk ditulis. Berikut ini adalah algoritma jaringan saraf multi-layer (BP) terbalik yang diimplementasikan oleh 70 baris kode, yaitu pembelajaran mendalam. Faktanya, ini bukan hanya jaringan saraf, tetapi sebagian besar algoritma pembelajaran mesin seperti regresi logistik, pohon keputusan C45/ID3, Hutan Acak, Bayesian, penyaringan kolaboratif, komputasi grafik, Kmeans, PageRank, dll. Dapat diimplementasikan dalam 100 baris program berdiri sendiri (pertimbangkan nanti).
Kesulitan sebenarnya dari pembelajaran mesin terletak pada mengapa ia menghitung seperti ini, apa prinsip matematika di baliknya, dan bagaimana menyimpulkan formula. Sebagian besar informasi di internet memperkenalkan bagian pengetahuan teoretis ini, tetapi jarang memberi tahu Anda bagaimana proses perhitungan dan implementasi program dari algoritma. Untuk pemrogram, yang perlu Anda lakukan hanyalah aplikasi rekayasa, dan tidak membuktikan metode perhitungan matematika baru. Faktanya, sebagian besar insinyur pembelajaran mesin menggunakan paket open source atau perangkat lunak alat yang ditulis oleh orang lain untuk memasukkan data dan menyesuaikan koefisien perhitungan untuk melatih hasil, dan jarang menerapkan proses algoritma sendiri. Namun, masih sangat penting untuk menguasai proses perhitungan masing -masing algoritma, sehingga Anda dapat memahami apa yang mengubah algoritma telah membuat data dan apa efek algoritma tersebut untuk dicapai.
Artikel ini berfokus pada implementasi mesin tunggal dari jaringan saraf terbalik. Mengenai paralelisasi multi-mesin dari jaringan saraf, FourInone memberikan kerangka komputasi paralel yang sangat fleksibel dan lengkap. Kami hanya perlu memahami implementasi program yang berdiri sendiri untuk memahami dan merancang solusi paralelisasi terdistribusi. Jika kita tidak memahami proses perhitungan algoritma, semua ide tidak akan dapat diperluas. Selain itu, ada juga jaringan saraf konvolusional, yang terutama merupakan ide pengurangan dimensi, yang digunakan untuk pemrosesan gambar, yang tidak berada dalam ruang lingkup artikel ini.
Deskripsi Proses Jaringan Saraf:
Pertama -tama, penting untuk menjelaskan bahwa jaringan saraf melakukan tugas prediksi. Saya yakin Anda ingat metode kuadrat terkecil yang Anda pelajari di sekolah menengah. Kita dapat menggunakan ini untuk membuat analogi yang kurang ketat tetapi lebih intuitif:
Pertama, kami ingin mendapatkan penanda dataset dan dataset (dalam metode kuadrat terkecil, kami juga mendapatkan satu set nilai x dan y)
Algoritma ini cocok dengan parameter fungsi yang dapat mengekspresikan kumpulan data ini berdasarkan set data ini dan tanda yang sesuai (yaitu, rumus yang menghitung A dan B dalam metode kuadrat terkecil, tetapi formula ini tidak dapat diperoleh secara langsung di jaringan saraf)
Kami mendapatkan fungsi yang dipasang (yaitu, garis yang dipasang y^= ax+b dalam metode kuadrat terkecil)
Selanjutnya, setelah membawa data baru, nilai prediksi yang sesuai dapat dihasilkan (dalam metode kuadrat terkecil, itu adalah untuk membawa y^= ax+b untuk mendapatkan prediksi y^, dan begitu juga algoritma jaringan saraf, tetapi fungsi yang diperoleh jauh lebih kompleks daripada metode kuadrat terkecil).
Proses perhitungan jaringan saraf
Struktur jaringan saraf ditunjukkan pada gambar di bawah ini. Yang paling kiri adalah lapisan input, yang paling kanan adalah lapisan output, dan tengah adalah beberapa lapisan tersembunyi. Setiap simpul saraf dari lapisan tersembunyi dan lapisan output diakumulasikan dengan mengalikan simpul lapisan sebelumnya dengan beratnya. Lingkaran bertanda "+1" adalah istilah intersep b. Untuk setiap node di luar lapisan input: y = w0*x0+w1*x1+...+wn*xn+b, kita dapat mengetahui bahwa jaringan saraf setara dengan struktur regresi logistik multi-lapisan.
Proses perhitungan algoritma: Lapisan input dimulai, menghitung dari kiri ke kanan, dan maju layer demi lapis sampai lapisan output menghasilkan hasilnya. Jika ada perbedaan antara nilai hasil dan nilai target, hitung dari kanan ke kiri, hitung kesalahan setiap lapisan node demi lapisan, dan sesuaikan semua bobot setiap node. Setelah mencapai lapisan input secara terbalik, hitung kembali ke depan, dan berikan langkah -langkah di atas sampai semua parameter bobot menyatu dengan nilai yang masuk akal. Karena program komputer memecahkan parameter persamaan dan metode matematika berbeda, mereka biasanya memilih parameter secara acak terlebih dahulu, dan kemudian terus -menerus menyesuaikan parameter untuk mengurangi kesalahan sampai nilai yang benar didekati, sebagian besar pembelajaran mesin terus -menerus merupakan pelatihan berulang. Mari kita lihat lebih dekat implementasi proses ini dari program.
Implementasi Program Algoritma dari Jaringan Saraf
Implementasi program algoritma dari jaringan saraf dibagi menjadi tiga proses: inisialisasi, hasil perhitungan ke depan, dan modifikasi terbalik bobot.
1. Proses Inisialisasi
Karena ini adalah jaringan saraf N-lapis, kami menggunakan lapisan array dua dimensi untuk merekam nilai node. Dimensi pertama adalah jumlah lapisan, dimensi kedua adalah posisi simpul lapisan, dan nilai array adalah nilai simpul; Demikian pula, Node Kesalahan Nilai Layererr juga dicatat dengan cara yang sama. Gunakan kelas tiga dimensi Layer_weight untuk merekam bobot setiap node. Dimensi pertama adalah jumlah lapisan, dimensi kedua adalah posisi simpul lapisan, dimensi ketiga adalah posisi simpul lapisan yang lebih rendah, nilai array adalah nilai bobot simpul yang mencapai lapisan yang lebih rendah, dan nilai awal adalah angka acak antara 0-1. Untuk mengoptimalkan kecepatan konvergensi, penyesuaian berat metode momentum digunakan di sini. Penting untuk merekam jumlah penyesuaian berat terakhir, dan menggunakan array tiga dimensi Layer_Weight_delta untuk merekam. Pemrosesan istilah intersep: Program menetapkan nilai intersep ke 1, sehingga hanya perlu menghitung bobotnya.
2. Hitung hasilnya
Fungsi S 1/(1+Math.exp (-z)) digunakan untuk menyatukan nilai masing-masing node ke antara 0-1, dan kemudian menghitungnya lapisan demi lapis sampai lapisan output. Untuk lapisan output, sebenarnya tidak perlu menggunakan fungsi S. Kami menganggap hasil output sebagai nilai probabilitas antara 0 dan 1, sehingga fungsi S juga digunakan, yang juga kondusif untuk keseragaman program.
3. Balikkan memodifikasi berat
Cara menghitung kesalahan dalam jaringan saraf umumnya menggunakan fungsi kesalahan persegi E, sebagai berikut:
Artinya, kotak kesalahan dari beberapa istilah output dan nilai target yang sesuai diakumulasikan dan dibagi dengan 2. Faktanya, ini adalah fungsi kesalahan regresi logistik. Mengenai mengapa fungsi ini digunakan untuk menghitung kesalahan, apa rasionalitas matematika dan bagaimana hal itu diperoleh, saya menyarankan agar pemrogram tidak ingin menjadi ahli matematika, jadi jangan masuk ke dalamnya secara mendalam. Yang perlu kita lakukan sekarang adalah bagaimana mengambil nilai minimum dari kesalahan fungsi ini dan perlu turunannya. Jika ada beberapa dasar matematika turunan, Anda dapat mencoba menyimpulkan cara mendapatkan rumus berikut dari bobot turunan fungsi e:
Tidak masalah jika kita tidak bisa menyimpulkannya. Kita hanya perlu menggunakan rumus hasil. Dalam program kami, kami menggunakan Layererr untuk merekam kesalahan yang diminimalkan setelah derivasi berat E, dan kemudian menyesuaikan berat sesuai dengan kesalahan yang diminimalkan.
Perhatikan bahwa metode momentum digunakan di sini untuk mempertimbangkan pengalaman penyesuaian sebelumnya untuk menghindari jatuh ke nilai minimum lokal. K di bawah ini mewakili jumlah iterasi, MOBP adalah istilah momentum, dan tingkat adalah langkah pembelajaran:
ΔW (k+1) = mobp*ΔW (k)+rate*err*lapisan
Ada juga banyak formula yang digunakan di bawah ini, dan perbedaan efeknya tidak terlalu besar:
ΔW (k+1) = mobp*ΔW (k)+(1-mobp) rate*err*lapisan
Untuk meningkatkan kinerja, perhatikan bahwa implementasi program adalah untuk menghitung kesalahan dan menyesuaikan bobot dalam beberapa saat. Pertama, posisikan posisi pada lapisan kedua ke terakhir (yaitu, lapisan tersembunyi terakhir), dan kemudian sesuaikan lapisan berat di lapisan terbalik. Sesuaikan berat lapisan L sesuai dengan kesalahan yang dihitung oleh lapisan L+1, dan hitung kesalahan lapisan L, dan hitung bobot lain kali siklus untuk menghitung berat hingga akhir lapisan pertama (lapisan input).
ringkasan
Selama seluruh proses perhitungan, nilai simpul berubah setiap kali dihitung dan tidak perlu disimpan. Parameter berat dan parameter kesalahan perlu disimpan dan perlu memberikan dukungan untuk iterasi berikutnya. Oleh karena itu, jika kita membayangkan solusi komputasi paralel multi-mesin terdistribusi, kita dapat memahami mengapa ada konsep server parameter dalam kerangka kerja lain.
Implementasi program lengkap dari jaringan saraf multi-lapisan
Program implementasi berikut BPDEEP.java dapat digunakan secara langsung, dan juga mudah untuk memodifikasinya ke implementasi bahasa lain seperti C, C#, Python, dll., Karena semuanya merupakan pernyataan dasar yang digunakan dan tidak ada perpustakaan Java lainnya (kecuali fungsi acak).
import java.util.Random;public class BpDeep{ public double[][] layer;//Neural network nodes public double[][] layerErr;//Neural network node error public double[][][] layer_weight;//Neural layer node weight public double[][][] layer_weight_delta;//Neural layer node weight momentum public double mobp;//Momentum coefficient public double rate; // koefisien pembelajaran BPDEEP publik (int [] layernum, rate ganda, mobp ganda) {this.mobp = mobp; this.rate = rate; layer = double [layerNum.length] baru []; Layererr = double baru [layerNum.length] []; Layer_weight = Double [LayERNUM.Length] baru baru [] []; Layer_weight_delta = double baru [layernum.length] [] []; Acak acak = acak baru (); untuk (int l = 0; l <layernum.length; l ++) {layer [l] = double baru [layernum [l]]; Layererr [l] = double baru [layernum [l]]; if (l+1 <layernum.length) {layer_weight [l] = double baru [layernum [l] +1] [layernum [l+1]]; layer_weight_delta [l] = double baru [layernum [l] +1] [layernum [l+1]]; untuk (int j = 0; j <layernum [l] +1; j ++) untuk (int i = 0; i <layernum [l+1]; i ++) layer_weight [l] [j] [i] = random.nextdouble (); // bobot inisialisasi acak}} // komputasi lapisan output berdasarkan output berdasarkan layer (); l = 1; l <layer.length; l ++) {for (int j = 0; j <layer [l] .length; j ++) {double z = layer_weight [l-1] [layer [l-1] .length] [j]; untuk (int i = 0; i <layer [l-1] .length; i ++) {layer [l-1] [i] = l == 1? Dalam [i]: layer [l-1] [i]; z+= Layer_weight [l-1] [i] [j]*layer [l-1] [i]; } layer [l] [j] = 1/(1+math.exp (-z)); }} return layer [layer.length-1]; } // Hitung secara terbalik dari lapisan kesalahan demi lapis dan memodifikasi berat badan pembaruan public void (ganda [] tar) {int l = layer.length-1; untuk (int j = 0; j <layererr [l] .length; j ++) layererr [l] [j] = layer [l] [j]*(1-layer [l] [j])*(tar [j] -layer [l] [j]); while (l-> 0) {for (int j = 0; j <layererr [l] .length; j ++) {double z = 0.0; untuk (int i = 0; i <layererr [l+1] .length; i ++) {z = z+l> 0? Layererr [l+1] [i]*Layer_weight [l] [j] [i]: 0; layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//Implant layer momentum adjustment layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//Implant layer weight adjustment if (j == Layererr [l] .length-1) {layer_weight_delta [l] [j+1] [i] = mobp*layer_weight_delta [l] [j+1] [i]+laju*layerr [l+1] [i]; // penyesuaian momentum intersep Layer_weight [l] [j+1] [i]+= layer_weight_delta [l] [j+1] [i]; // penyesuaian berat intersep}} layerr [l] [j] = z*layer [l] [j]*(1-layer [l] [j] [j]);//Catatan kesalahan {l]} {1-layer [l] [l] [j]);//Catatan kesalahan}} {1-layer [l] [l] [j]); // Rekam kesalahan}} {1 layer [l] [l] [j]); menghitung (dalam); kelas pembaruan (TAR); }}Contoh menggunakan jaringan saraf
Akhirnya, mari kita temukan contoh sederhana untuk melihat efek magis dari jaringan saraf. Untuk memfasilitasi pengamatan distribusi data, kami memilih data koordinat dua dimensi. Ada 4 data di bawah ini. Blok mewakili jenis data adalah 1, dan segitiga mewakili jenis data adalah 0. Anda dapat melihat bahwa data yang termasuk dalam tipe blok adalah (1, 2) dan (2, 1), dan data yang termasuk dalam jenis segitiga adalah (1, 1), (2, 2). Sekarang masalahnya adalah kita perlu membagi 4 data menjadi 1 dan 0 pada pesawat, dan menggunakannya untuk memprediksi jenis data baru.
Kita dapat menggunakan algoritma regresi logistik untuk menyelesaikan masalah klasifikasi di atas, tetapi regresi logistik memperoleh garis lurus linier sebagai garis pemisah. Anda dapat melihat bahwa tidak peduli bagaimana garis merah di atas ditempatkan, sampel selalu salah dibagi menjadi berbagai jenis. Oleh karena itu, untuk data di atas, hanya satu garis lurus tidak dapat membagi klasifikasi mereka dengan benar. Jika kita menggunakan algoritma jaringan saraf, kita bisa mendapatkan efek klasifikasi dari gambar di bawah ini, yang setara dengan menemukan penyatuan beberapa garis lurus untuk membagi ruang, yang lebih tinggi dalam akurasi.
Berikut adalah kode sumber dari program pengujian ini bpdeeptest.java:
Impor java.util.arrays; kelas publik bpdeeptest {public static void main (string [] args) {// menginisialisasi konfigurasi dasar jaringan saraf // parameter pertama adalah array integer, yang mewakili jumlah lapisan jaringan saraf dan jumlah node per lapisan. For example, {3, 10, 10, 10, 10, 2} means that the input layer is 3 nodes, the output layer is 2 nodes, and there are 4 hidden layers in the middle, and 10 nodes per layer //The second parameter is the learning step size, and the third parameter is the momentum coefficient BpDeep bp = new BpDeep(new int[]{2, 10, 2}, 0.15, 0.8); // Atur data sampel, sesuai dengan 4 data koordinat dua dimensi di atas [] [] data = double baru [] [] {{1,2}, {2,2}, {1,1}, {2,1}}; // Atur data target, sesuai dengan klasifikasi 4 koordinat data ganda [] [] target = double baru [] [] {{1,0}, {0,1}, {0,1}, {1,0}}; // pelatihan iteratif 5000 kali untuk (int n = 0; n <5000; n ++) untuk (int i = 0; i <data.length; i ++) bp.train (data [i], target [i]); // Periksa data sampel berdasarkan hasil pelatihan untuk (int j = 0; j <data.length; j ++) {double [] hasil = bp.computeout (data [j]); System.out.println (arrays.tostring (data [j])+":"+arrays.tostring (hasil)); } // Prediksi klasifikasi data baru berdasarkan hasil pelatihan ganda [] x = ganda baru [] {3,1}; ganda [] hasil = bp.computeout (x); System.out.println (arrays.tostring (x)+":"+arrays.tostring (hasil)); }} ringkasan
Program pengujian di atas menunjukkan bahwa jaringan saraf memiliki efek klasifikasi magis. Faktanya, jaringan saraf memiliki keunggulan tertentu, tetapi mereka bukan algoritma universal yang dekat dengan otak manusia. Berkali -kali itu mungkin mengecewakan kita. Kita juga perlu menggunakan banyak data dari berbagai skenario untuk mengamati efeknya. Kita dapat mengubah lapisan tersembunyi 1-layer ke lapisan-N dan menyesuaikan jumlah node, iterasi, ukuran langkah belajar dan koefisien momentum per lapisan untuk mendapatkan hasil yang dioptimalkan. Namun, dalam banyak kasus, efek lapisan tersembunyi N-lapis tidak meningkat secara signifikan daripada lapisan 1. Sebaliknya, perhitungannya lebih kompleks dan memakan waktu. Pemahaman kami tentang jaringan saraf membutuhkan lebih banyak latihan dan pengalaman.
Di atas adalah semua konten yang dibagikan dalam artikel ini tentang menerapkan algoritma jaringan saraf dalam dengan 70 baris kode Java. Saya harap ini akan membantu semua orang. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya.