Buat jaringan saraf sederhana

Terjemahan dari Pembuatan Jaringan Saraf Sederhana

Apa yang akan kita lakukan Kami akan mencoba membuat jaringan saraf yang sederhana dan sangat kecil, yang akan kami jelaskan dan ajarkan kepada Anda untuk membedakan sesuatu. Pada saat yang sama, kami tidak akan masuk ke dalam sejarah dan hutan matematika (informasi seperti itu sangat mudah ditemukan) - sebagai gantinya, kami akan mencoba menjelaskan masalahnya (bukan fakta bahwa itu akan mungkin) kepada Anda dan diri kita sendiri dengan gambar dan kode.

Banyak istilah dalam jaringan saraf terkait dengan biologi, jadi mari kita mulai dari awal:


Otak adalah hal yang rumit, tetapi juga dapat dibagi menjadi beberapa bagian utama dan operasi:



Agen penyebab juga bisa bersifat internal (misalnya, gambar atau ide):



Sekarang mari kita lihat bagian dasar dan disederhanakan dari otak:


Otak umumnya terlihat seperti jaringan kabel.

Neuron adalah unit utama kalkulus di otak, ia menerima dan memproses sinyal kimiawi dari neuron lain, dan, bergantung pada sejumlah faktor, tidak melakukan apa-apa, atau menghasilkan impuls listrik, atau Potensi Tindakan, yang kemudian mengirimkan sinyal ke neuron yang terhubung melalui sinapsis:



Mimpi, ingatan, gerakan yang mengatur diri sendiri, refleks, dan memang segala sesuatu yang Anda pikirkan atau lakukan adalah semua karena proses ini: jutaan atau bahkan milyaran neuron bekerja pada tingkat yang berbeda dan menciptakan koneksi yang menciptakan subsistem paralel yang berbeda dan mewakili jaringan saraf biologis .

Tentu saja, ini semua adalah penyederhanaan dan generalisasi, tetapi berkat mereka kita dapat menggambarkan yang sederhana
jaringan saraf:



Dan jelaskan secara formal menggunakan grafik:



Diperlukan beberapa klarifikasi di sini. Lingkaran adalah neuron, dan garis adalah koneksi di antara mereka,
dan, agar tidak menyulitkan pada tahap ini, hubungan adalah pergerakan informasi langsung dari kiri ke kanan . Neuron pertama saat ini aktif dan berwarna abu-abu. Kami juga memberinya nomor (1 - jika berfungsi, 0 - jika tidak). Angka-angka di antara neuron menunjukkan bobot koneksi.

Grafik di atas menunjukkan waktu saat jaringan, untuk tampilan yang lebih akurat, Anda perlu membaginya menjadi periode waktu:



Untuk membuat jaringan saraf Anda sendiri, Anda perlu memahami bagaimana bobot mempengaruhi neuron dan bagaimana neuron dilatih. Sebagai contoh, ambil kelinci (kelinci percobaan) dan letakkan dalam kondisi percobaan klasik.



Saat aliran udara aman diarahkan ke mereka, kelinci, seperti orang-orang, berkedip:



Model perilaku ini dapat dibuat grafik:



Seperti pada diagram sebelumnya, grafik ini hanya menunjukkan saat ketika kelinci merasakan nafas, dan dengan cara ini kami memberi kode pukulan sebagai nilai logis. Selain itu, kami menghitung apakah neuron kedua dipicu berdasarkan nilai berat. Jika angka 1, maka neuron sensorik dipicu, kita berkedip; jika beratnya kurang dari 1, kita tidak berkedip: neuron kedua memiliki batas 1.

Kami memperkenalkan satu elemen lagi - sinyal suara yang aman:



Kita bisa memodelkan minat kelinci sebagai berikut:



Perbedaan utama adalah bahwa sekarang beratnya nol , jadi kami belum menerima kelinci yang berkedip, setidaknya untuk saat ini. Sekarang ajari kelinci untuk berkedip pada tim, campur
iritan (sinyal suara dan nafas):



Penting bahwa peristiwa ini terjadi dalam periode waktu yang berbeda , dalam grafik akan terlihat seperti ini:



Suara itu sendiri tidak melakukan apa-apa, tetapi aliran udara masih membuat kelinci berkedip, dan kami menunjukkannya melalui bobot yang dikalikan dengan rangsangan (merah).

Belajar tentang perilaku kompleks dapat secara sederhana dinyatakan sebagai perubahan berat badan secara bertahap antara neuron yang terhubung dari waktu ke waktu.

Untuk melatih kelinci, ulangi langkah-langkahnya:



Untuk tiga upaya pertama, skema akan terlihat seperti ini:



Perhatikan bahwa bobot untuk stimulus suara tumbuh setelah setiap pengulangan (disorot dengan warna merah), nilai ini sekarang berubah-ubah - kami memilih 0,30, tetapi angkanya bisa apa saja, bahkan negatif. Setelah pengulangan ketiga, Anda tidak akan melihat perubahan dalam perilaku kelinci, tetapi setelah pengulangan keempat sesuatu yang mengejutkan akan terjadi - perilaku tersebut akan berubah.



Kami menghilangkan efek dari udara, tetapi kelinci masih berkedip ketika dia mendengar bunyi bip! Perilaku terakhir ini dapat menjelaskan perilaku ini:



Kami melatih kelinci untuk merespons suara dengan berkedip.


Dalam percobaan nyata semacam ini, lebih dari 60 pengulangan mungkin diperlukan untuk mencapai hasil.

Sekarang kita akan meninggalkan dunia biologis otak dan kelinci dan mencoba menyesuaikan semua itu
belajar membuat jaringan saraf tiruan. Pertama, mari kita coba melakukan tugas sederhana.

Katakanlah kita memiliki mesin dengan empat tombol yang menghasilkan makanan saat Anda menekan kanan
tombol (baik, atau energi jika Anda robot). Tugasnya adalah mencari tahu tombol mana yang memberi hadiah:



Kami dapat menggambarkan (secara skematis) apa yang dilakukan tombol ketika diklik sebagai berikut:



Masalah ini paling baik diselesaikan secara keseluruhan, jadi mari kita lihat semua hasil yang mungkin, termasuk yang benar:


Tekan tombol ke-3 untuk mendapatkan makan malam Anda.

Untuk mereproduksi jaringan saraf dalam kode, pertama-tama kita perlu membuat model atau grafik yang dengannya jaringan dapat dikaitkan. Berikut adalah satu grafik yang cocok untuk tugas tersebut, selain itu, grafik ini juga menampilkan rekanan biologisnya:



Jaringan saraf ini baru saja menerima informasi yang masuk - dalam hal ini akan menjadi persepsi tombol mana yang ditekan. Selanjutnya, jaringan menggantikan informasi yang masuk dengan bobot dan membuat kesimpulan berdasarkan penambahan layer. Kedengarannya agak membingungkan, tetapi mari kita lihat bagaimana tombol disajikan dalam model kami:


Perhatikan bahwa semua bobot adalah 0, sehingga jaringan saraf, seperti bayi, benar-benar kosong, tetapi sepenuhnya saling berhubungan.

Dengan demikian, kami membandingkan peristiwa eksternal dengan lapisan input dari jaringan saraf dan menghitung nilai pada outputnya. Mungkin atau mungkin tidak bersamaan dengan kenyataan, tetapi untuk sekarang kita akan mengabaikannya dan mulai menggambarkan tugas dengan cara yang ramah komputer. Mari kita mulai dengan memasukkan bobot (kita akan menggunakan JavaScript):

var inputs = [0,1,0,0]; var weights = [0,0,0,0]; //       

Langkah selanjutnya adalah membuat fungsi yang mengumpulkan nilai input dan menimbang serta menghitung nilai pada output:

 function evaluateNeuralNetwork(inputVector, weightVector){ var result = 0; inputVector.forEach(function(inputValue, weightIndex) { layerValue = inputValue*weightVector[weightIndex]; result += layerValue; }); return (result.toFixed(2)); } //   ,  ,    —    /    

Seperti yang diharapkan, jika kita menjalankan kode ini, kita akan mendapatkan hasil yang sama seperti pada model atau grafik ...

 evaluateNeuralNetwork(inputs, weights); // 0.00 

Contoh langsung: Neural Net 001 .

Langkah selanjutnya dalam meningkatkan jaringan saraf kita akan menjadi cara untuk memeriksa output sendiri atau nilai hasil yang sebanding dengan situasi nyata,
pertama-tama mari kita enkode realitas khusus ini menjadi variabel:



Untuk mendeteksi ketidakkonsistenan (dan berapa banyak), kami menambahkan fungsi kesalahan:

 Error = Reality - Neural Net Output 

Dengan itu, kita dapat mengevaluasi kinerja jaringan saraf kita:



Tetapi yang lebih penting, bagaimana dengan situasi di mana realitas memberikan hasil positif?



Sekarang kita tahu bahwa model jaringan saraf kita tidak berfungsi (dan kita tahu seberapa banyak), hebat! Ini bagus karena sekarang kita dapat menggunakan fungsi kesalahan untuk mengontrol pembelajaran kita. Tetapi semua ini akan masuk akal jika kita mendefinisikan kembali fungsi kesalahan sebagai berikut:

 Error = <b>Desired Output</b> - Neural Net Output 

Kesenjangan yang sulit dipahami, tetapi begitu penting, secara diam-diam menunjukkan bahwa kita akan melakukannya
gunakan hasil yang diperoleh sebelumnya untuk membandingkan dengan tindakan di masa depan
(dan untuk pelatihan, seperti yang akan kita lihat nanti). Itu ada dalam kehidupan nyata, penuh dengan
pola berulang, sehingga bisa menjadi strategi evolusi (well, in
kebanyakan kasus).

Selanjutnya, dalam kode sampel kami, kami akan menambahkan variabel baru:

 var input = [0,0,1,0]; var weights = [0,0,0,0]; var desiredResult = 1; 

Dan fitur baru:

 function evaluateNeuralNetError(desired,actual) { return (desired — actual); } // After evaluating both the Network and the Error we would get: // "Neural Net output: 0.00 Error: 1" 

Contoh langsung: Neural Net 002 .

Untuk meringkas subtotal . Kami mulai dengan tugas, membuat model sederhana dalam bentuk jaringan saraf biologis, dan mendapatkan cara untuk mengukur kinerjanya dibandingkan dengan kenyataan atau hasil yang diinginkan. Sekarang kita perlu menemukan cara untuk memperbaiki perbedaan - suatu proses yang dapat dianggap sebagai pelatihan untuk komputer dan orang-orang.

Bagaimana cara melatih jaringan saraf?

Dasar mengajar jaringan saraf biologis dan buatan adalah pengulangan
dan algoritma pelatihan , jadi kami akan bekerja dengannya secara terpisah. Mulai dengan
algoritma pembelajaran.

Secara alami, algoritma pembelajaran dipahami sebagai perubahan fisik atau kimia
karakteristik neuron setelah percobaan:



Sebuah ilustrasi dramatis tentang bagaimana dua neuron berubah dari waktu ke waktu dalam kode dan model kami "algoritma pembelajaran" berarti bahwa kami hanya akan mengubah sesuatu dari waktu ke waktu untuk membuat hidup kita lebih mudah. Karena itu, mari kita tambahkan variabel untuk menunjukkan tingkat fasilitasi kehidupan:

 var learningRate = 0.20; //   ,      :) 

Dan apa yang akan berubah?

Ini akan mengubah berat (seperti kelinci!), Terutama bobot hasil yang kita inginkan:



Bagaimana kode algoritma semacam itu adalah pilihan Anda, untuk kesederhanaan saya menambahkan koefisien pelatihan ke bobot, ini dia dalam bentuk fungsi:

 function learn(inputVector, weightVector) { weightVector.forEach(function(weight, index, weights) { if (inputVector[index] > 0) { weights[index] = weight + learningRate; } }); } 

Ketika digunakan, fungsi pembelajaran ini hanya akan menambah koefisien pembelajaran kami ke vektor bobot neuron aktif , sebelum dan sesudah lingkaran pelatihan (atau pengulangan), hasilnya adalah sebagai berikut:

 // Original weight vector: [0,0,0,0] // Neural Net output: 0.00 Error: 1 learn(input, weights); // New Weight vector: [0,0.20,0,0] // Neural Net output: 0.20 Error: 0.8 //    ,      1 ( ) — ,    ,    ,       

Contoh langsung: Neural Net 003 .

Oke, sekarang kita bergerak ke arah yang benar, detail terakhir dari teka-teki ini adalah pengenalan pengulangan .

Tidak begitu sulit, di alam kita hanya melakukan hal yang sama berulang-ulang, dan dalam kode kita hanya mengindikasikan jumlah pengulangan:

 var trials = 6; 

Dan pengantar jaringan pelatihan saraf kita tentang fungsi jumlah pengulangan akan terlihat seperti ini:

 function train(trials) { for (i = 0; i < trials; i++) { neuralNetResult = evaluateNeuralNetwork(input, weights); learn(input, weights); } } 

Nah, laporan akhir kami:

 Neural Net output: 0.00 Error: 1.00 Weight Vector: [0,0,0,0] Neural Net output: 0.20 Error: 0.80 Weight Vector: [0,0,0.2,0] Neural Net output: 0.40 Error: 0.60 Weight Vector: [0,0,0.4,0] Neural Net output: 0.60 Error: 0.40 Weight Vector: [0,0,0.6,0] Neural Net output: 0.80 Error: 0.20 Weight Vector: [0,0,0.8,0] Neural Net output: 1.00 Error: 0.00 Weight Vector: [0,0,1,0] // Chicken Dinner ! 

Contoh langsung: Neural Net 004 .

Sekarang kita memiliki vektor bobot yang hanya akan memberikan satu hasil (ayam untuk makan malam), jika vektor input sesuai dengan kenyataan (menekan tombol ketiga).

Jadi apa yang keren yang baru saja kita lakukan?

Dalam kasus khusus ini, jaringan saraf kita (setelah pelatihan) dapat mengenali input data dan mengatakan apa yang akan mengarah pada hasil yang diinginkan (kita masih perlu memprogram situasi tertentu):



Selain itu, ini adalah model, mainan, dan alat yang dapat diskalakan untuk pelatihan kami. Kami dapat mempelajari sesuatu yang baru tentang pembelajaran mesin, jaringan saraf, dan kecerdasan buatan.

Perhatian kepada pengguna:

• Mekanisme penyimpanan untuk skala yang diteliti tidak disediakan, jadi jaringan saraf ini akan melupakan semua yang diketahuinya. Saat memperbarui atau memulai ulang kode, Anda memerlukan setidaknya enam percobaan ulang yang berhasil sehingga jaringan sepenuhnya terlatih jika Anda berpikir bahwa seseorang atau mesin akan menekan tombol secara acak ... Ini akan memakan waktu.
  
• Jaringan biologis untuk mempelajari hal-hal penting memiliki kecepatan belajar 1, jadi Anda hanya perlu satu pengulangan yang berhasil.
  
• Ada algoritma pembelajaran yang sangat mirip dengan neuron biologis, ia memiliki nama yang menarik: aturan widroff-hoff , atau pelatihan widroff-hoff .
  
• Ambang batas neuron (1 dalam contoh kami) dan efek pelatihan ulang (dengan sejumlah besar pengulangan, hasilnya akan lebih dari 1) tidak diperhitungkan, tetapi mereka sangat penting di alam dan bertanggung jawab untuk blok besar dan kompleks dari reaksi perilaku. Seperti bobot negatif.
  

Catatan dan referensi untuk bacaan lebih lanjut

Saya mencoba menghindari matematika dan istilah-istilah yang ketat, tetapi jika Anda tertarik, kami membangun perceptron , yang didefinisikan sebagai algoritme untuk pembelajaran yang diawasi ( mengajar dengan guru ) pengklasifikasi ganda - hal yang sulit.

Struktur biologis otak bukanlah topik yang sederhana, sebagian karena ketidaktepatan, sebagian karena kompleksitasnya. Yang terbaik adalah memulai dengan Neuroscience (Purves) dan Cognitive Neuroscience (Gazzaniga). Saya memodifikasi dan mengadaptasi contoh kelinci dari Gateway to Memory (Gluck), yang juga merupakan panduan hebat bagi dunia grafik.

Sumber lain yang luar biasa, Pengantar Jaringan Saraf Tiruan (Gurney), cocok untuk semua kebutuhan terkait AI Anda.

Dan sekarang dengan Python! Terima kasih kepada Ilya Andschmidt untuk versi Python yang disediakan:

 inputs = [0, 1, 0, 0] weights = [0, 0, 0, 0] desired_result = 1 learning_rate = 0.2 trials = 6 def evaluate_neural_network(input_array, weight_array): result = 0 for i in range(len(input_array)): layer_value = input_array[i] * weight_array[i] result += layer_value print("evaluate_neural_network: " + str(result)) print("weights: " + str(weights)) return result def evaluate_error(desired, actual): error = desired - actual print("evaluate_error: " + str(error)) return error def learn(input_array, weight_array): print("learning...") for i in range(len(input_array)): if input_array[i] > 0: weight_array[i] += learning_rate def train(trials): for i in range(trials): neural_net_result = evaluate_neural_network(inputs, weights) learn(inputs, weights) train(trials) 

Dan sekarang GO! Terima kasih untuk versi Kieran Maher ini.

 package main import ( "fmt" "math" ) func main() { fmt.Println("Creating inputs and weights ...") inputs := []float64{0.00, 0.00, 1.00, 0.00} weights := []float64{0.00, 0.00, 0.00, 0.00} desired := 1.00 learningRate := 0.20 trials := 6 train(trials, inputs, weights, desired, learningRate) } func train(trials int, inputs []float64, weights []float64, desired float64, learningRate float64) { for i := 1; i < trials; i++ { weights = learn(inputs, weights, learningRate) output := evaluate(inputs, weights) errorResult := evaluateError(desired, output) fmt.Print("Output: ") fmt.Print(math.Round(output*100) / 100) fmt.Print("\nError: ") fmt.Print(math.Round(errorResult*100) / 100) fmt.Print("\n\n") } } func learn(inputVector []float64, weightVector []float64, learningRate float64) []float64 { for index, inputValue := range inputVector { if inputValue > 0.00 { weightVector[index] = weightVector[index] + learningRate } } return weightVector } func evaluate(inputVector []float64, weightVector []float64) float64 { result := 0.00 for index, inputValue := range inputVector { layerValue := inputValue * weightVector[index] result = result + layerValue } return result } func evaluateError(desired float64, actual float64) float64 { return desired - actual }