Ada banyak artikel di Internet dengan deskripsi algoritma gradient descent. Akan ada satu lagi.

Pada 8 Juli 1958, The New York Times menulis : “Seorang psikolog menunjukkan cikal bakal komputer yang dirancang untuk membaca dan menjadi lebih bijaksana. Dikembangkan oleh Angkatan Laut ... komputer $ 704, yang menelan biaya $ 2 juta, belajar untuk membedakan antara kiri dan kanan setelah lima puluh upaya ... Menurut Angkatan Laut, mereka menggunakan prinsip ini untuk membangun mesin pemikiran pertama dari kelas Perceptron, yang dapat membaca dan menulis; pengembangan direncanakan akan selesai dalam satu tahun, dengan total biaya $ 100.000 ... Para ilmuwan memperkirakan bahwa nantinya Perceptrons akan dapat mengenali orang dan memanggil mereka dengan nama, langsung menerjemahkan pidato lisan dan tertulis dari satu bahasa ke bahasa lain. Mr Rosenblatt mengatakan bahwa pada prinsipnya adalah mungkin untuk membangun "otak" yang dapat mereproduksi diri mereka sendiri di jalur perakitan dan yang akan menyadari keberadaan mereka sendiri "(dikutip dan diterjemahkan dari buku oleh S. Nikolenko," Pembelajaran mendalam, pencelupan dalam dunia jaringan saraf ").

Ah, jurnalis ini tahu bagaimana cara membuat intrik. Sangat menarik untuk mengetahui apa sebenarnya mesin berpikir dari kelas Perceptron.

Klasifikasi biner (biner) objek, neuron buatan dari kelas Perceptron

Ini adalah neuron buatan kita, ia membagi objek menjadi dua kelas (melakukan klasifikasi objek biner):

Jadi kita punya:

• Input: objek pengambilan sampel - vektor ruang m-dimensi $$$x = (x_1, ..., x_m)$
• Bobot $$$w = (w_1, ..., w_m)$ satu untuk setiap fitur objek sampel (juga vektor m-dimensi)
• Di dalam: adder $$$SUM = w_1x_1 + ... + w_mx_m = \ jumlah _ {j = 1} ^ {m} w_ {j} x_ {j}$ - jumlah input neuron tertimbang
• Berikutnya: aktivasi $$$Φ (x, w) = Φ (SUM)$
• Lebih jauh lagi: quantizer (threshold) - θ [theta]
• Aktivasi + ambang batas - prediksi label kelas suatu objek berdasarkan pada jumlah input neuron yang terbobot (atribut objek). Bagian ini mendefinisikan arsitektur spesifik neuron.
• Output: label kelas objek (satu dari dua) $$$\ hat {y} = \ {1, -1 \}$

Klasifikasi - karena neuron memberikan kelas ke objek, biner ( biner ) - karena hanya ada dua kelas yang mungkin.

$$$\ hat {y}$ [permainan dengan penutup] - kami akan menunjukkan nilai kelas yang diprediksi (dihitung) untuk objek $$$x$
$$$y$ [permainan reguler tanpa penutup] - true (dikenal) nilai-nilai kelas untuk suatu objek $$$x$ dari set pelatihan.

Nilai-nilai $$$x$ (selanjutnya $$$x$ dan $$$w$ - ini bukan nilai satuan, tetapi vektor) bervariasi dari objek ke objek, koefisien berat $$$w$ (sekali dipilih) tetap tidak berubah. Untuk set pelatihan untuk setiap objek $$$x$ label kelas dikenal $$$y$ . Pada tahap pelatihan, Anda harus memilih bobot $$$w$ sehingga model menghasilkan nilai yang benar $$$\ hat {y}$ (bertepatan dengan $$$y$ ) untuk jumlah objek maksimum dalam set pelatihan. Asumsi kegunaan neuron yang dilatih dengan cara ini didasarkan pada harapan bahwa itu akan menghasilkan nilai yang benar dengan koefisien yang dipilih $$$\ hat {y}$ untuk objek baru $$$x$ nilai kelas yang benar $$$y$ yang tidak diketahui sebelumnya.

Arti intuitif dari jumlah tertimbang dari input neuron adalah bahwa semua atribut dari suatu objek (masing-masing tanda adalah salah satu input dari neuron) mempengaruhi hasil klasifikasi objek, tetapi tidak semua tanda sama-sama terpengaruh. Sejauh mana - menentukan berat; memberi nol pada koefisien bobot tertentu membatalkan kontribusi atribut yang sesuai dengan jumlah total, mis. ini sama saja dengan menghapus fitur dari objek.

Adaptif Linear Neuron ADALINE

Neuron ADALINE (neuron linier adaptif) adalah neuron buatan biasa dengan fungsi aktivasi ini:

$$

$$Φ (x, w) = Φ (SUM) = SUM$$

$$

$$\ Phi (x ^ {(i)}, w) = \ Phi (\ jumlah _ {j = 1} ^ {m} w_ {j} x_ {j} ^ {(i)}) = \ sum _ { j = 1} ^ {m} w_ {j} x_ {j} ^ {(i)}$$

Selanjutnya superskrip $$$i$ dalam kurung akan menunjukkan $$$i$ elemen dari set pelatihan $$$x ^ {(i)}$ atau nilai kelas yang benar $$$y ^ {(i)}$ atau nilai kelas yang diprediksi $$$\ hat {y} ^ {(i)}$ untuknya.

Kita dapat mengatakan bahwa neuron semacam itu sama sekali tidak memiliki fungsi aktivasi dan nilai jumlah input tertimbang diumpankan ke input quantizer (ambang). Tetapi untuk konsistensi, akan lebih mudah untuk mengasumsikan bahwa nilai dari jumlah tertimbang diambil sebagai aktivasi.

Threshold (quantizer) - memprediksi label kelas:

$$

$$\ hat {y} ^ {(i)} = \ kiri \ {\ begin {matrix} 1, \ Phi (x ^ {(i)}, w) \ ge \ theta \\ - 1, \ Phi (x ^ {(i)}, w) <\ theta \ end {matrix} \ benar.$$

Jika nilai aktivasi lebih besar dari beberapa nilai ambang θ [theta], maka quantizer memberikan label “1” ke objek, jika nilai aktivasi kurang dari ambang θ, objek menerima label “-1”.

Di sini kita dapat merumuskan masalah dalam perkiraan pertama : kita perlu memilih parameter neuron

• faktor pembobotan $$$w_j, j = 1, .., m$
• dan ambang θ [theta]

sehingga nilai-nilai kelas $$$\ hat y$ , yang ditugaskan neuron ke objek sampel pelatihan, bertepatan dengan nilai sebenarnya dari kelas $$$y$ untuk elemen yang sama (atau, setidaknya, memberi arti yang benar untuk mayoritas).

Kami mengubah fungsi ambang sedikit, mengambil kasus untuk kelas $$$\ hat y = 1$ dan mentransfer ambang ke sisi kiri ketidaksetaraan:

$$

$$\ begin {collected} \ Phi (x ^ {(i)}, w) \ ge \ theta \ hfill \\ jumlah _ {j = 1} ^ {m} w_ {j} x_ {j} ^ {( i)} \ ge \ theta \ hfill \\ - \ theta + \ sum _ {j = 1} ^ {m} w_ {j} x_ {j} ^ {(i)} \ ge 0 \ hfill \\ \ end {collected}$$

menunjukkan $$$w_ {0} = - \ theta$ dan $$$x_ {0} = 1$

$$

$$\ begin {collected} w_ {0} x_ {0} ^ {(i)} + \ sum _ {j = 1} ^ {m} w_ {j} x_ {j} ^ {(i)} \ ge 0 , w_ {0} = - \ theta, x_ {0} = 1 \ hfill \\ jumlah _ {j = 0} ^ {m} w_ {j} x_ {j} ^ {(i)} \ ge 0, x_ {0} = 1 \ hfill \ end {collected}$$

Seperti yang kita lihat, kami berhasil menyingkirkan parameter yang terpisah θ, memperkenalkannya dengan kedok koefisien bobot baru $$$w_0$ di bawah tanda jumlah, sambil menambahkan ke deskripsi objek tanda unit boneka baru $$$x_0 = 1$ .

Kami akan memperbaiki rumusan masalah dengan mempertimbangkan notasi baru.

Tugas ' : pilih parameter faktor pembobot neuron $$$w_j, j = 0, .., m$ ,
$$$x_0 = 1$ (tanda-konstan) - neuron fiktif ( neuron pemindahan )

Mulai dari tempat ini, kami menomori tanda dan bobot c 0, bukan 1. Tentang vektor $$$w$ kita akan mengatakan bahwa ini tentang (m + 1) -dimensi, dan bukan m-dimensional. Vektor $$$x$ tergantung pada konteksnya, kita dapat mempertimbangkan (m + 1) -dimensi (sebagian besar dalam rumus), tetapi ingat bahwa sebenarnya itu adalah m-dimensional.

Mengapa neuron ( dalam kasus kami, bagaimanapun, ini bukan neuron, tetapi tanda suatu objek atau hanya input, tetapi dalam kasus jaringan multilayer berubah menjadi neuron dan biasanya disebut demikian ) adalah fiktif - sudah jelas sekarang. Kenapa dia juga perpindahan akan menjadi jelas nanti.

Aktivasi dengan jumlah sekarang akan terlihat seperti ini:

$$

$$\ Phi (x ^ {(i)}, w) = \ Phi (\ jumlah _ {j = 0} ^ {m} w_ {j} x_ {j} ^ {(i)}) = \ sum _ { j = 0} ^ {m} w_ {j} x_ {j} ^ {(i)}, x_ {0} ^ {(i)} = 1 \ forall i$$

Ambang sekarang selalu 0 (nol) (nilai riil dipindahkan ke parameter $$$w_0$ ):

$$

$$\ hat {y} ^ {(i)} = \ kiri \ {\ begin {matrix} 1, \ Phi (x ^ {(i)}, w) \ ge 0 \\ - 1, \ Phi (x ^ {(i)}, w) <0 \ end {matrix} \ benar.$$

Sekali lagi kami merumuskan masalah dengan kata lain (makna geometris masalah)

Jika kita hati-hati melihat rumus untuk fungsi aktivasi, kita akan melihat bahwa itu adalah hyperplane parametrik dalam ruang dimensi (m + 1), sedangkan pada dimensi m pertama ia berdampingan dengan titik-titik elemen sampel, dan (m + 1) - Dimensi-e adalah ruang nilai fungsi, terpisah dari elemen.

Sekarang, jika kita menyamakan nilai aktivasi ke nol (nilai ambang batas), maka ini juga akan menjadi hyperplane, hanya sudah ada di ruang m-dimensional, mis. sepenuhnya di ruang nilai elemen $$$x$ . Hyperplane ini akan memisahkan elemen. $$$x$ menjadi dua kelompok terpisah.

Biasanya di tempat ini mereka mengatakan bahwa tugas kita adalah memilih nilai parameter $$$w$ , yaitu buatlah sebuah hyperplane m-dimensional dalam ruang elemen sehingga elemen-elemen dari pelatihan yang ditetapkan dengan nilai sebenarnya dari kelas "1" berada di satu sisi pesawat, dan elemen dengan kelas sejati "-1" di sisi lain.

Bagi mereka yang tidak mengerti apa yang ditulis di sini, baca terus - sekarang kita semua akan melihat, ini yang pertama. Kedua, kita juga akan melihat bahwa pernyataan masalah seperti itu, meskipun valid, tidak sepenuhnya lengkap.

Ruang satu dimensi (m = 1)

Di sinilah kode mulai muncul. Kami membangun semua grafik dengan perpustakaan Matplotlib biasa, tapi di sini saya juga menggunakan perpustakaan Seaborn dalam satu baris untuk menyesuaikan area grafik, karena Saya suka bagaimana dia melakukannya, tetapi pada prinsipnya Anda dapat melakukannya tanpa dia.

# coding=utf-8 import matplotlib.pyplot as plt import seaborn as sns #      # (    -> ) sns.set(style='whitegrid', font_scale=1.8) #sns.set(style='whitegrid') #   ,   seaborn #plt.rcParams.update({'font.size': 16}) 

Kami mengambil banyak poin 1-dimensi dan menjawabnya:

 import numpy as np import math #  -  ( ) X1 = np.array([1, 2, 6, 8, 10]) #   ( ) y = np.array([-1, -1, 1, 1, 1]) 

Di sini kita memiliki setiap elemen ke-i dari array X1 - ini adalah elemen ke-i (titik ke-th) dari sampel pelatihan (lebih tepatnya, atribut 1 dan satu-satunya): $$$x ^ {(i)} = (X1 [i])$ , $$$x ^ {(i)} _ 1 = X1 [i]$

Setiap elemen ke-i dari array y adalah jawaban yang benar, label sejati yang sesuai dengan elemen ke-i dari sampel pelatihan dengan atribut tunggal X1 [i].

Kami hanya mengambil 5 poin, dua yang pertama ditugaskan ke kelas "-1", tiga sisanya ditugaskan ke kelas "1".

Gambarlah poin-poin ini di telepon:

 #  =0 plt.plot(X1, np.zeros(len(X1)), color='black', lw=2) #     =0 plt.scatter(X1[y==1], np.full(len(X1[y==1]), 0), color='blue', marker='o', s=300, label=u' x (1 ): -1 (y=1)') plt.scatter(X1[y==-1], np.full(len(X1[y==-1]), 0), color='red', marker='s', s=300, label=u' x (1 ): -2 (y=-1)') plt.xlabel(u'X1 ( )') plt.ylabel(u' ()') plt.legend(loc='upper left') plt.show() 

Sekarang mari kita lihat fungsi aktivasi:

$$

$$\ Phi = w_ {0} + w_ {1} x_ {1}$$

Seperti yang Anda lihat, ini adalah garis parametrik biasa pada bidang (dalam 2-dimensi, mis. (M + 1) -dimensi ruang):

• pada sumbu horizontal kita memiliki titik-titik elemen (mereka juga nilai-nilai atribut X1)
• pada nilai aktivasi - vertikal untuk setiap elemen
• parameter $$$w_1$ - Menetapkan sudut kemiringan,
• tapi $$$w_0$ - bergeser di sepanjang sumbu vertikal (inilah jawaban untuk neuron geser ).

 w0 = -1.1 w1 = 0.4 #  y_ = w0 + w1*X1 #   (   -    ) plt.plot(X1, y_, color='violet', lw=3, label=u': w0=%0.2f, w1=%0.2f, sse/2=%0.2f'% (w0, w1, sse/2)) # :    =0 plt.scatter([-w0/w1], [0], color='violet', marker='o', s=300, label=u' ') #       plt.scatter(X1[y==1], y_[y==1], color='lightblue', marker='o', s=200, label=u': -1 (y=1)') plt.scatter(X1[y==-1], y_[y==-1], color='pink', marker='s', s=200, label=u': -2 (y=-1)') 

Ingat juga bahwa setelah konversi kecil, ambang aktivasi kami berubah menjadi nol. Dengan demikian, jika proyeksi elemen ke-i ke garis aktivasi lebih rendah dari nol, kami menetapkan kelas -1 ke elemen ( $$$\ hat {y} = -1$ ), jika lebih tinggi dari nol, kami menetapkan kelas "1" ( $$$\ hat {y} = 1$ )

Titik ungu - persimpangan garis aktivasi dengan sumbu $$$\ Phi = 0$ , memisahkan elemen dari kelas yang berbeda, ini adalah hyperplane yang sangat terpisah (untuk ruang 1-dimensi, intinya adalah hyperplane) yang dibangun dalam ruang fitur 1-dimensi (mis. m-dimensional). Seperti yang Anda lihat, untuk membagi elemen menjadi kelompok, itu sudah cukup, tetapi untuk menetapkan kelas ke grup, itu tidak lagi cukup. Untuk menetapkan kelas ke elemen, kita memerlukan aktivasi (hyperplane 2-dimensi) langsung yang dibangun dalam 2-d (yaitu, dalam (m + 1) -d) ruang "tanda + aktivasi": arah deviasi aktivasi dari vertikal sumbu akan menentukan kelas untuk kelompok elemen, karena itu tergantung pada apakah proyeksi elemen pada aktivasi lebih tinggi atau lebih rendah dari nol.

Mengubah parameter $$$w_0$ dan $$$w_1$ kami akan menerima jalur aktivasi yang berbeda. Kita perlu membangun jalur aktivasi seperti itu, mis. temukan kombinasi parameter seperti itu $$$w$ di mana proyeksi dua poin pertama dari sampel pelatihan pada garis aktivasi di bawah nol (bagi mereka, nilainya $$$\ hat {y} = y = -1$ ), dan proyeksi 3 poin sisanya akan berada di atas nol (untuk mereka $$$\ hat {y} = y = 1$ )

Cukup jelas bahwa dalam kasus khusus kami tidak ada yang rumit dalam membangun garis seperti itu, apalagi, garis tersebut umumnya dapat dibangun dalam jumlah tak terbatas. Tetapi kami akan mencoba membangunnya sedemikian rupa sehingga beberapa kriteria optimalitas dipenuhi (dapat mempengaruhi kualitas prediksi masa depan), ditambah harus ada kemampuan untuk memperluas algoritma ke kasus multidimensi.

Di sini kami juga mencatat bahwa kami secara khusus memilih set poin awal sehingga dapat dibagi dengan garis seperti itu (untuk 1-e: semua elemen dari kelompok pertama lebih kecil, semua elemen dari kelompok kedua lebih besar dari beberapa nilai tetap), yaitu. banyak poin pelatihan terpisah secara linear .

Tambahkan dua garis horizontal lagi ke grafik yang sesuai dengan kelas {1, -1}, dan proyeksikan elemen ke atasnya.

 #      (y=1, y=-1) plt.plot(X1, np.full(len(X1), 1), color='blue', label=u': -1 (y=1)') plt.plot(X1, np.full(len(X1), -1), color='red', label=u': -2 (y=-1)') #       (y=1, y=-1) plt.scatter(X1[y==1], np.full(len(X1[y==1]), 1), color='lightblue', marker='o', s=200, label=u' y: -1 (y=1)') plt.scatter(X1[y==-1], np.full(len(X1[y==-1]), -1), color='pink', marker='s', s=200, label=u' y: -2 (y=-1)') 

Poin dengan proyek "-1" kelas ke garis bawah $$$\ Phi = -1$ , poin dengan proyek kelas "1" ke baris teratas $$$\ Phi = 1$ .

Mari kita perhatikan satu lagi nuansa kecil. Kami memplot nilai aktivasi sepanjang sumbu vertikal, ruang nilai aktivasi kontinu. Tetapi hasil dari classifier (fungsi aktivasi melewati ambang) adalah satu set diskrit dari dua elemen {-1, 1}, dan bukan skala kontinu. Di sini kita mengambil satu set kelas diskrit $$$y$ dan letakkan pada skala aktivasi berkelanjutan $$$\ Phi$ sehingga nilai kelas diskrit menjadi titik biasa pada skala aktivasi - kasus khusus nilai aktivasi yang dapat langsung diterima atau didekati cukup dekat dengan mereka. Sebenarnya, kita awalnya tidak dapat mengambil nilai numerik sebagai kelas, tetapi string label "class-1" dan "class-2", dalam hal ini kita harus mencocokkan label string dengan nilai numerik pada skala aktivasi. Oleh karena itu, dalam kasus kami, nilai-nilai kelas "-1" dan "1" harus diambil bukan sebagai label kelas seperti mereka, tetapi sebagai pemetaan kelas yang ditandai untuk skala aktivasi.

Saatnya untuk memasukkan metrik kesalahan

 #   -       #      plt.plot([X1, X1], [y_, y], color='orange', lw=3)#, label='err') 

Adalah wajar untuk menerima bahwa semakin dekat nilai aktivasi untuk elemen yang dipilih adalah dengan nilai kelas untuk elemen yang sama, semakin baik prediksi kelas aktivasi untuk elemen ini. Jadi, untuk kesalahan untuk elemen yang dipilih, Anda dapat mengambil jarak antara titik - proyeksi vertikal elemen pada garis aktivasi dan proyeksi elemen pada garis horizontal dari kelas yang diketahui (benar). Pada grafik: kesalahan - garis oranye vertikal.

Fungsi biaya (kerugian)

Kami memiliki metrik kesalahan untuk setiap item individual. Kita dapat memperolehnya dari metrik kualitas untuk seluruh jalur aktivasi. Sangat wajar untuk menerima, misalnya, bahwa semakin kecil jumlah kesalahan semua elemen sampel pelatihan, semakin baik kita membangun jalur aktivasi. Untuk setiap elemen individu, kesalahannya tidak akan minimal, tetapi untuk seluruh sampel pelatihan secara keseluruhan, Anda bisa mendapatkan beberapa kompromi.

Tapi Anda bisa mengambil bukan jumlah kesalahan sederhana, tetapi jumlah kesalahan kuadrat ( jumlah kesalahan kuadrat, jumlah kesalahan kuadrat, SSE ). Sangat jelas bahwa, seperti dalam kasus jumlah kesalahan biasa, semakin dekat garis aktivasi ke titik dengan kelas elemen yang benar, semakin kecil jumlah kesalahan kuadrat, tetapi dalam kasus kesalahan kuadrat, elemen yang paling jauh akan menerima penalti yang lebih parah.

Sebenarnya, yang menarik bagi kita di sini bukanlah ukuran denda untuk elemen yang jauh, tetapi fakta bahwa fungsi kuadratik memiliki minimum dan dapat dibedakan di mana-mana (jumlah yang biasa akan memiliki minimum, tetapi pada minimum ini tidak akan dapat dibedakan), lihat mengapa ini perlu. sedikit kemudian.

Jadi:

• Kesalahan - jarak dari nilai label kelas ke hyperplane aktivasi
• SSE - jumlah kesalahan kuadrat semua elemen sampel pelatihan
• Fungsi biaya $$$J (w)$ - metrik kualitas untuk jalur aktivasi yang dipilih. Semakin rendah nilainya, semakin baik aktivasi.

Ambil sebagai fungsi nilai $$$1 \ lebih dari 2$ SSE, dalam kasus umum untuk neuron linier, akan terlihat seperti ini:

$$

$$\ begin {collected} J (w) = {1 \ lebih dari 2} SSE = {1 \ lebih dari 2} \ jumlah _ {i = 1} ^ {n} (\ Phi (\ jumlah _ {j = 0} ^ {m} w_ {j} x_ {j} ^ {(i)}) - y ^ {(i)}) ^ {2} = {1 \ lebih dari 2} \ jumlah _ {i = 1} ^ {n} (\ jumlah _ {j = 0} ^ {m} w_ {j} x_ {j} ^ {(i)} - y ^ {(i)}) ^ {2} \ end {collected}$$

( $$$1 \ lebih dari 2$ di tempat pertama, itu tidak mengganggu SSE, dan, kedua, untuk kenyamanan - itu akan dikurangi dengan indah)

Di sini $$$i$ - nomor elemen, dan $$$n$ - jumlah elemen dalam set pelatihan. Biarkan saya mengingatkan Anda itu $$$y ^ {(i)}$ - kelas sejati $$$i$ elemen sampel pelatihan, mis. Jawaban benar terkenal sebelumnya.

Seperti yang kita ingat, posisi jalur aktivasi ditentukan oleh parameter - faktor bobot $$$w$ oleh karena itu vektor $$$w$ bertindak sebagai parameter dari fungsi kerugian.

Untuk kasus 1 dimensi

$$

$$J (w) = {1 \ lebih dari 2} SSE = {1 \ lebih dari 2} \ sum_ {i = 1} ^ {n} (w_ {0} + w_ {1} x_ {1} ^ {(i) } -y ^ {(i)}) ^ {2}$$

Nilai-nilai $$$x$ dan $$$y$ diketahui sebelumnya (ini adalah set pelatihan), oleh karena itu mereka diperbaiki. Kami memilih parameter $$$w$ , yaitu $$$w_0$ dan $$$w_1$ sehingga nilainya $$$J (w)$ Ternyata sangat minim. Mari kita coba plot grafik sebagai nilainya $$$J (w)$ tergantung pada parameternya $$$w_0$ dan $$$w_1$

 #      w0 = np.linspace(-10, 10, 200) w1 = np.linspace(-1, 1, 200) # https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html # https://stackoverflow.com/questions/36060933/matplotlib-plot-a-plane-and-points-in-3d-simultaneously ww0, ww1 = np.meshgrid(w0, w1) sse = [] for j in range(len(w1)): sse.append([]) for i in range(len(w0)): sse[j].append(((ww0[j][i]+ww1[j][i]*X1 - y)**2).sum()) sse = np.array(sse) # https://matplotlib.org/mpl_toolkits/mplot3d/tutorial.html # https://matplotlib.org/api/toolkits/mplot3d.html from mpl_toolkits.mplot3d import axes3d fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.set_xlabel('w0') ax.set_ylabel('w1') ax.set_zlabel('J(w)') #ax.plot_surface(ww0, ww1, sse/2, color='lightblue', rstride=8, cstride=8) ax.plot_wireframe(ww0, ww1, sse/2, color='lightblue', rstride=8, cstride=8, label='SSE/2') plt.xlim(-10., 10.) plt.ylim(-1., 1.) plt.legend() plt.show() 

Secara umum, sudah terlihat di sini bahwa fungsi kerugian memiliki minimum, dan di mana ia berada kira-kira. Tetapi mari kita lakukan satu trik lagi dan membangun grafik yang sama, hanya dengan skala vertikal logaritmik .

 #ax.plot_surface(ww0, ww1, np.log(sse/2), color='lightblue', rstride=8, cstride=8) ax.plot_wireframe(ww0, ww1, np.log(sse/2), color='lightblue', rstride=8, cstride=8, label='log(SSE/2)') 

Saya tidak tahu tentang Anda, tetapi secara pribadi, ketika saya melihat bagan ini untuk pertama kalinya, saya mengalami pencerahan. Rongga alami ini bukan hanya visualisasi figuratif dari bukit multidimensi dari artikel populer di jaringan saraf, ini adalah grafik nyata.

Tugas kami adalah memilih nilai-nilai tersebut $$$w_0$ dan $$$w_1$ untuk sampai ke dasar lubang ini. Kami mendapatkan nilai bobot - kami mendapatkan neuron yang terlatih.

Karena kita semua sama-sama membuat grafik dan secara pribadi mengamati minimumnya, tidak seorang pun akan melarang kita untuk menemukan koordinatnya dengan enumerasi sederhana di grid "secara manual":

 #      # https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.min.html # https://docs.scipy.org/doc/numpy/reference/generated/numpy.amin.html#numpy.amin # https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmin.html min_ind = np.unravel_index(np.argmin(sse), sse.shape) #  -  #ax.scatter(ww0[min_ind], ww1[min_ind], sse[min_ind]/2, color='red', marker='o', s=100, ax.scatter(ww0[min_ind], ww1[min_ind], math.log(sse[min_ind]/2), color='red', marker='o', s=100, label='min: w0=%0.2f, w1=%0.2f, SSE/2=%0.2f' % (ww0[min_ind], ww1[min_ind], sse[min_ind]/2)) 

Inilah nilainya: $$$w_0 = -1,26$ dan $$$w_1 = 0,27$ , jumlah kesalahan kuadrat dari SSE adalah 0,69, fungsi biaya $$$J (w) = SSE / 2 = 0,35$ (lebih tepatnya: 0,3456478371758288).

Mari kita lihat bagaimana aktivasi terlihat dengan parameter ini:

 #  ""   (SSE=0.69, sse/2=0.345) w0 = -1.26 w1 = 0.27 

Bagi saya, itu cukup normal. Titik potong aktivasi dengan ambang nol memisahkan elemen dari kelas yang berbeda, dan aktivasi itu sendiri memberi mereka nilai yang benar. Pada saat yang sama, aktivasi tampaknya berada dalam posisi optimal.

Sebelum melanjutkan, kami kembali mengagumi grafik di grid yang lebih luas:

Tampaknya tidak ada posisi terendah lain di dekatnya yang akan berpikir.

Pencarian minimum

Jadi, kami mendapat bobot - koordinat nilai kesalahan minimum. Ini akan menjadi nilai optimal dari bobot pada sampel pelatihan. Secara umum, inilah yang kita butuhkan, kita dapat mengatakan bahwa neuron dilatih. Mungkin ini bisa diselesaikan?

Cari minimum: cari berdasarkan kisi

• Sekilas opsi ini cukup berfungsi (seperti yang kita lihat)
• Anda harus tahu sebelumnya area tempat mencari minimum (Anda dapat mengambil batas yang cukup besar, lalu mempersempit area pencarian - ini hanya dengan mata)
• Untuk meningkatkan akurasi, Anda perlu mengurangi langkah → bahkan lebih banyak poin (solusi: Anda dapat secara sempit mempersempit area pencarian)
• Terlalu banyak poin (untuk 2d mungkin ok, tapi untuk kasus multidimensi kita berlari ke sumber daya dengan sangat cepat)
• Untuk MNIST (28x28 = 784 piksel - jumlah input yang sama, faktor bobot yang sama plus offset, kisi 100 langkah per dimensi): 100 ^ 785 = 10 ^ 1570.

Jadi, jika kita ingin melatih satu neuron (bahkan bukan jaringan saraf) dalam gambar 28x28 = 784 piksel dengan mencari minimum dengan penghitungan langsung pada kisi 100 titik untuk setiap pengukuran, kita perlu memilah 10 ^ 1570 kombinasi. Ini cukup banyak untuk penyimpanan dan pencarian (di bagian Semesta yang terlihat hanya ada 10 ^ 80 atom, Semesta ada selama sekitar 4 * 10 ^ 17 detik = 4 * 10 ^ 26 nanodetik).

Mari kita coba mencari opsi lebih cepat.

Pencarian Minimum: Keturunan Langkah Konstan

Mari kita lihat grafik dari fungsi kerugian $$$J (w)$ di pesawat: perbaiki $$$w_0$ berubah $$$w_1$

 def sse_(X, y, w0, w1): return ((w0+w1*X - y)**2).sum() #  w0,   J(w1)=sse(w1)/2 w1 = np.linspace(-1, 1, 200) sse = [[], [], []] for i in range(len(w1)): sse[0].append(sse_(X1, y, -1, w1[i])) sse[1].append(sse_(X1, y, 0, w1[i])) sse[2].append(sse_(X1, y, 1, w1[i])) sse = np.array(sse) plt.plot(w1, sse[0]/2, color='orange', label='w0=-1') plt.plot(w1, sse[1]/2, color='blue', label='w0=0') plt.plot(w1, sse[2]/2, color='red', label='w0=1') plt.xlabel('w1') plt.ylabel('J(w)') plt.legend() plt.show() 

Ini adalah parabola biasa (lebih tepatnya, keluarga parabola - mereka akan sedikit berbeda tergantung pada apa nilai yang ditetapkan pada $$$w_0$ ) Untuk menemukan parabola minimum, tidak perlu memilah-milah semua poin. Kita dapat memilih titik sembarang pada sumbu horizontal dan bergerak menuju minimum dengan beberapa langkah.

Pertimbangkan opsi nada yang konstan

• Jika langkah terlalu besar, Anda dapat meleset, dan tidak mencapai minimum (langkah tersebut dapat dikurangi)
• Jika terlalu kecil, akan ada terlalu banyak langkah (lebih dari yang seharusnya)
• Bagaimanapun, kami tidak akan mencapai minimum yang tepat, tetapi kami dapat mencapainya dengan akurasi sewenang-wenang dengan mengubah langkah di dekat minimum yang tidak akurat yang ditemukan (langkah tidak lagi konstan)
• Kami tidak tahu arah penurunan (dimungkinkan untuk menyelesaikan secara algoritmik: jangan melangkah ke arah meningkatnya kesalahan)
• Masalah dengan menemukan rentang telah diselesaikan (Anda dapat turun dari mana saja - cepat atau lambat kami akan turun pula)
• Pada prinsipnya, opsi ini berfungsi, tetapi mungkin ada opsi yang lebih baik?

Catatan: ketika saya berbicara tentang opsi turun ke kuliah, seorang siswa bertanya mengapa Anda perlu bergerak dalam langkah-langkah jika Anda dapat segera menemukan parabola minimum menggunakan rumus? Pada awalnya, saya menjawab sesuatu dengan semangat sehingga kami sekarang tertarik untuk mempertimbangkan opsi iterasi, sehingga nantinya kami dapat menggunakannya tidak hanya dengan parabola, tetapi juga dalam situasi lain. Plus, pada kenyataannya, kami tidak membutuhkan setidaknya parabola khusus pada bagian ini - kami akan pindah ke minimum tidak dalam satu dimensi, tetapi dalam semua dimensi sedemikian rupa sehingga pada setiap iterasi baru langkah baru akan berlangsung tidak sepanjang parabola ini, tetapi pada parabola dengan irisan baru dengan nilai bergeser $$$w_0$ . Tetapi berpikir kemudian, saya berpikir bahwa, pada prinsipnya, tidak ada yang salah jika kita bergerak di setiap irisan, tidak dalam langkah-langkah, tetapi segera turun ke minimum irisan saat ini. Jadi, dari waktu ke waktu, pengukuran demi pengukuran, kita masih harus meluncur ke minimum global, dan tampaknya lebih cepat daripada langkah-langkahnya. Untuk satu neuron, ia seharusnya bekerja, dan tidak hanya dengan parabola. Tetapi saya belum mulai membuang waktu untuk menguji teori ini, jadi di sini kita lanjutkan saja - saya berjanji untuk berbicara tentang gradient descent.

Cari minimum: gradient descent

Secara umum, kami menuruni tangga, tetapi kami melakukannya dengan lebih cerdas. Kami menggunakan turunan dari kurva biaya untuk memilih langkah (di sini, bukan kurva biaya , tetapi kurva biaya ).

• Kami memiliki beberapa dimensi dan masing-masing memiliki kurva sendiri: kami memperbaiki semuanya $$$w_j$ kecuali $$$w_k$ ,
• $$$J (w_k)$ akan ada kurva kesalahan di $$$k$ dimensi th
• Semuanya adalah (dalam kasus kami) parabola, tetapi, secara umum, hanya penting bahwa mereka dapat dibedakan di mana-mana dan memiliki minimum
• Untuk menyesuaikan langkah dalam setiap pengukuran, kami akan menggunakan turunan parsial dari fungsi kesalahan sehubungan dengan pengukuran ini (koefisien yang bervariasi $$$w_k$ )
• Vektor dari turunan parsial seperti itu disebut gradien.

Ini semua baik, tetapi dari mana turunannya berasal? Sekarang mari kita cari tahu.

Arti geometris dari turunan

Bagi saya, turunan untuk waktu yang lama tetap satu set formula dan aturan khusus untuk perhitungannya, ditambah sesuatu tentang kenaikan, penurunan, dan ekstrem. Di sini akan tepat untuk mengingat atau mencari tahu apa sebenarnya derivatif itu.

Fungsi turunan $$$y (x)$ pada titik ini $$$x_0$ Apakah batas rasio kenaikan fungsi $$$\ Delta y$ untuk kenaikan argumen $$$\ Delta x$ saat menambah argumen $$$\ Delta x$ cenderung nol:

$$

$$y '(x_0) = \ lim _ {\ Delta x \ to 0} {\ Delta y \ over \ Delta x}, \ Delta y = y (x_0 + \ Delta x) - y (x_0)$$

Titik di gambar $$$M (x_0, y (x_0)) = (x_0, y_0)$ Adalah titik di mana kita ingin menentukan turunannya. Point $$$N (x_0 + \ Delta x, y (x_0 + \ Delta x)) = (x_0 + \ Delta x, y_0 + \ Delta y)$ - Poin yang diperoleh dengan menambah argumen $$$\ Delta x$ . Langsung $$$Mn$ - Garis potong melewati dua titik ini.

Point $$$A$ - persimpangan garis potong $$$Mn$ dengan sumbu horizontal $$$y = 0$ .

Pertimbangkan dua segitiga siku-siku: segitiga $$$\ segitiga NPM$ dengan bagian garis potong $$$Mn$ sebagai sisi miring dan segitiga $$$\ segitiga MBA$ dengan kelanjutan garis potong pada sumbu $$$y = 0$ - segmen $$$AM$ sebagai sisi miring. Dari grafik dan geometri sekolah tentu terlihat jelas sudutnya $$$\ angle NMP$ dan $$$\ angle MAB$ sama, dan oleh karena itu garis singgung mereka sama:

$$

$$\ tan \ angle MAB = \ tan \ angle NMP = {MB \ over AB} = {NP \ over MP} = {\ Delta y \ over \ Delta x}$$

Tambahkan ke gambar: $$$MD$ - bersinggungan dengan kurva awal pada titik tersebut $$$M$ melintasi sumbu $$$y = 0$ pada intinya $$$D$ . Segitiga $$$\ triangle MBD$ - segitiga siku-siku dengan sisi miring - bagian kaset, ruas $$$MD$ .

Kami mengincar kenaikan tersebut $$$\ Delta x$ ke nol:

Point $$$N$ pindah ke titik $$$M$ berdasarkan fungsi, titik $$$A$ merayap ke suatu titik $$$D$ sepanjang sumbu $$$y$ garis potong $$$Mn$ berubah menjadi garis singgung $$$MD$ dengan titik sentuh $$$M$ . Sumber segitiga $$$\ segitiga NPM$ dengan kaki $$$\ Delta x$ dan $$$\ Delta y$ menyusut ke suatu titik, tetapi segitiga seperti itu $$$\ segitiga MBA$ berubah menjadi segitiga $$$\ triangle MBD$ melestarikan tidak hanya dimensi makroskopis, tetapi juga persamaan sudut $$$\ angle MAB$ dan $$$\ angle NMP$ .

Bagaimana kenaikannya $$$\ Delta x$ , mendekati nol tanpa batas, tidak akan pernah mencapai nol, begitu intinya $$$N$ tidak pernah sampai ke tempat yang tepat $$$M$ titik $$$A$ tidak akan mencapai titik $$$D$ segitiga $$$\ segitiga MBA$ tidak akan berubah menjadi $$$\ triangle MBD$ . , , «» $$$\lim$ .

$$$\triangle MBA$ — $$$\triangle MBD$ , :

$$

$$\lim_{\Delta x \to 0}{\Delta y \over \Delta x} = \lim_{\Delta x \to 0}{\tan \angle NMP} = \lim_{\Delta x \to 0}{\tan \angle MAB} = \lim_{\Delta x \to 0}{MB \over AB} = {MB \over DB} = \tan \angle MDB$$

:

$$

$$\lim_{\Delta x \to 0}{\Delta y \over \Delta x} = \tan \angle MDB$$

, , :

$$

$$y'(x_0) = \lim_{\Delta x \to 0}{\Delta y \over \Delta x} = \tan \angle MDB$$

, $$$y=0$ . .

, , , , , . , , , , .. ( , , ). : , (, — tangent line , , — ).

:

• $$$x_0$ $$$y=0$
• — $$$y(x_0)$ — $$$x_0$ $$$y=0$ $$$y=0$
• «» , ,
• — : — , —
• ( , , , $$$\Delta y$ )

, , :

— , — $$$x_0$ , — . — — . — $$$y=0$ , — .

, , , , . ( , ) (: $$$y=0$ , ).

( ): , (: $$$y=0$ , ).

, : (), «»/«» , . — . , , ? .

$$$J(w)$ . , , , .

$$

$$J(w)={1 \over 2} SSE ={1 \over 2}\sum _{i=1}^{n}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)})^{2}$$

• $$$k$ -
• ,

$$

$$\begin{gathered}\frac{\partial J(w)}{\partial w_{k}} ={\frac{\partial }{\partial w_{k}}}{1 \over 2}\sum _{i=1}^{n}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)})^{2} ={1 \over 2}\sum _{i=1}^{n}{\frac{\partial }{\partial w_{k}}}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)})^{2} \\={1\over 2}\sum _{i=1}^{n}2(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)}) \frac{\partial }{\partial w_{k}}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)}) \\={1\over 2}2\sum _{i=1}^{n}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)}) \frac{\partial }{\partial w_{k}}((w_{0}x_{0}^{(i)}+...+w_{k}x_{k}^{(i)}+...+w_{m}x_{m}^{(i)}) - y^{(i)}) \\=\sum _{i=1}^{n}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)})x_{k}^{(i)} \end{gathered}$$

, : , , , ( ) . , $$$w_k$ ( , ), . , , , $$$1/2$ SSE .

:

$$

$$\begin{gathered}\frac{\partial J(w)}{\partial w_{k}} =\sum _{i=1}^{n}(\sum _{j=0}^{m}w_{j}x_{j}^{(i)} - y^{(i)})x_{k}^{(i)} \end{gathered}$$

— ( $$$\nabla$ [], , .. []):

$$

$$\nabla J(w)=(\frac{\partial J(w)}{\partial w_{0}},...,\frac{\partial J(w)}{\partial w_{m}}), w=(w_{0},...,w_{m})$$

:

$$

$$w:=w+\Delta w, \Delta w=-\eta \nabla J(w)$$

$$$k$ - :

$$

$$w_{k}:=w_{k}+\Delta w_{k}, \Delta w_{k}=-\eta \frac{\partial J(w)}{\partial w_{k}}$$

:

• $$$\eta$ [] — ,

, , , . , .

1- :

$$

$$\Phi(x, w)=w_0+w_1x_1$$

( ):

$$

$$\frac{\partial J(w)}{\partial w_{0}} =\sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}-y^{(i)})x_{0}^{(i)} =\sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}-y^{(i)})$$

$$

$$\frac{\partial J(w)}{\partial w_{1}}= \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}-y^{(i)})x_{1}^{(i)}$$

:

$$

$$\Delta w_{0}=-\eta \frac{\partial J(w)}{\partial w_{0}}=-\eta \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}-y^{(i)})$$

$$

$$\Delta w_{1}=-\eta \frac{\partial J(w)}{\partial w_{1}}=-\eta \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}-y^{(i)})x_{1}^{(i)}$$

, . .

( $$$w_1$ )

$$$w_0=1$ , $$$J(w_1)$

$$$X$ ( ) $$$y$ $$$w_0$ dan $$$w_1$ ( ):

 def sse_(X, y, w0, w1): return ((w0+w1*X - y)**2).sum() 

$$$w_1$ -1.5 1.5.

  #      w0 = 1 w1 = np.linspace(-1.5, 1.5, 200) #              numpy.dot # https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html #    ,      sse = [] for i in range(len(w1)): sse.append(sse_(X1, y, w0, w1[i])) sse = np.array(sse) 

, ( , , ):

  plt.subplot(3,1,1) # sse plt.plot(w1, sse/2, color='red', label='w0=1') #  -   w1_first = .9 plt.scatter(w1_first, sse_(X1, y, w0, w1_first)/2, color='blue', marker='o', s=100) plt.xlim(-1.2, 1.2) plt.xlabel(u'w1') plt.ylabel(u'J(w1, w0=1)') plt.legend(loc='lower left') 

, , $$${\delta J(w)} \over {\delta w_1}$ — :

  grad_w1 = [] for i in range(len(w1)): grad = ((w0 + w1[i]*X1 - y)*X1).sum() grad_w1.append(grad) plt.subplot(3,1,3) plt.plot(w1, grad_w1, label=u' ∂J(w)/∂w1') plt.xlim(-1.2, 1.2) plt.xlabel(u'w1') plt.ylabel(u'∂J(w)/∂w1') plt.legend(loc='upper left') 

$$$\Delta w_1(w_1)$ (, $$$\Delta w_1$ $$$w_1$ , .. , ):

  eta = 0.001 delta_w1 = [] for i in range(len(w1)): grad = ((w0 + w1[i]*X1 - y)*X1).sum() delta = -eta*grad delta_w1.append(delta) plt.subplot(3,1,2) plt.plot(w1, delta_w1, color='orange', label=u'Δw1, η=%s'%eta) plt.xlim(-1.2, 1.2) plt.xlabel(u'w1') plt.ylabel(u'Δw1=-η*∂J(w)/∂w1') plt.legend(loc='upper right') 

  plt.show() 

• : ,
• : — «» ( , «» ),
• : — ( ), $$$\eta$ [] ( ),

: , 1000 .

, ,

$$$w$ — - - . $$$w_0=1$ , $$$w_1=0.9$ . $$$\eta=0.001$ ( , ) 12:

  #    12-14  eta = 0.001 epochs = 12 

:

  #      w1_epochs = [w1_first] delta_w1_epochs = [] w1_next = w1_first for i in range(epochs): grad = ((w0 + w1_next*X1 - y)*X1).sum() delta = -eta*grad w1_next = w1_next + delta delta_w1_epochs.append(delta) w1_epochs.append(w1_next) #   - 0 delta_w1_epochs.append(0) w1_epochs = np.array(w1_epochs) delta_w1_epochs = np.array(delta_w1_epochs) #     sse_epochs = [] for i in range(len(w1_epochs)): sse_epochs.append(sse_(X1, y, w0, w1_epochs[i])) sse_epochs = np.array(sse_epochs) 

$$$w_1$ $$$J(w_1, w_0=1)$ :

  #     -       size_epochs = [10 + (250-100)*epoch/epochs for epoch in reversed(range(epochs+1))] plt.scatter(w1_epochs, sse_epochs/2, color='blue', marker='o', s=size_epochs, label=u'  , η=%s'%eta) #    w1 plt.plot([w1_epochs, w1_epochs+delta_w1_epochs], [sse_epochs/2, sse_epochs/2], color='orange')#, label='Δw1') 

$$$\Delta w_1(w_1)$

 plt.scatter(w1_epochs, delta_w1_epochs, color='blue', marker='o', s=size_epochs, label=u'  , η=%s'%eta) plt.plot([w1_epochs, w1_epochs], [delta_w1_epochs, np.zeros(len(delta_w1_epochs))], color='orange') 

, , ( ), . , , , .

: , , , «» , — , .

• — $$$w_1$ , —
• , $$$w_1$
• — : , —
• , —
• , ( ), , ( ) — , —
• ( , — ).
• : — , —
• ? — . .
• . $$$w_1$ , . , «»/«» . , , . , , , « ». , : $$$w_1=0.9$ 200, , , , 1. , , , . — $$$\eta$ . , 200 1. $$$\eta=0.001$ , $$$w_1=0.9$ 200*0.001=0.2 ( -1, -0.2) — .
• $$$J(w_1=0.9)=92.43$ , 12 (, ) $$$J(w_1=0.03)=8.54$
• , ,

, . , . , ( , ). $$$\eta$ , .

: , , , .

, , , .

$$$\eta$

• $$$\eta$ [] — ()
• ,
• «»: , , ,
• , $$$J(w)$
• : $$$w_k$ , $$$\eta$ , $$$w_k$

$$$\eta=0.01$

 #    eta = 0.01 epochs = 6 

. , . 3- , 3- , , .. , .. . , , [] .

$$$\eta$ $$$J(w)$ $$$\eta$

  #      J(w0, w1)   w0  w1 #    12-14  eta = 0.001 epochs = 12 #  -   #   w0  w1 -  ,   , #    10-15  # NB: (    , , ,  , #      ) w0_first = -.9 w1_first = -.9 #      w0_epochs = [w0_first] w1_epochs = [w1_first] delta_w0_epochs = [] delta_w1_epochs = [] w0_next = w0_first w1_next = w1_first for i in range(epochs): grad_w0 = (w0_next + w1_next*X1 - y).sum() delta_w0 = -eta*grad_w0 grad_w1 = ((w0_next + w1_next*X1 - y)*X1).sum() delta_w1 = -eta*grad_w1 w0_next = w0_next + delta_w0 w1_next = w1_next + delta_w1 delta_w0_epochs.append(delta_w0) delta_w1_epochs.append(delta_w1) w0_epochs.append(w0_next) w1_epochs.append(w1_next) #     sse_epochs = [] for i in range(len(w1_epochs)): sse = sse_(X1, y, w0_epochs[i], w1_epochs[i]) sse_epochs.append(sse) print('epoch=%d, w0=%f, w1=%f, SSE/2=%f' % (i, w0_epochs[i], w1_epochs[i], sse/2)) sse_epochs = np.array(sse_epochs) #  -      η (--) plt.plot(range(len(sse_epochs)), sse_epochs, label=u'J(w)=SSE/2, η=%s'%eta) plt.xlabel(u'epoch (η=%s)'%eta) plt.ylabel(u'J(w)') plt.legend(loc='upper right') plt.show() 

: , , . , — , , .

:

 #   eta = 0.001 epochs = 50 

:

 #    eta = 0.01 epochs = 8 

.

$$$\eta$ . , , .

, .

:

• : , , ( ). , , , , .
• : .

, ( ) $$$w$ , , . , , , . , , .

,

, .

, :

— :

12 — , :

50 :

1767 — , :

, 62000 :

:

. , : , , . , , , , , , . , , - .

, , - , - : , , , , , — . , , , , , , , — . ?

, . :

, , ( ). : , . , , .

. , .

. , , . , — .

— :

11- : , ; :

12- : , , :

50- : , 12-

1766: . $$$J(w)=0.3456480221$ — , , ( $$$J(w)=0.3456478372$ : 6- , , )

1767: $$$J(w)=0.34564503$ — , ( 6- , ). $$$w_0=-1.184831$ , $$$w_1=0.258455$ ( $$$w_0$ 2- : $$$w_0=-1.27$ , $$$w_1=0.26$ )

62000: $$$J(w)=0.3445945$ — , ( 2- ). :

:

. , , , , .

• $$$\eta=0.001$ , 10-12- ( )
• , , , (1767)
• — 60
• —

— ( , 1767): $$$w_0=-1.184831$ , $$$w_1=0.258455$ .

.

$$$t^{(1)}=(t_1^{(1)})=(1.4)$ ( , $$$t^{(i)}$ — ). , .. , , $$$\hat y=-1$ , .. .

$$

$$SUM=w_0 + w_1*t_1^{(1)} = -1.18 + 0.26*1.4=-0.816$$

$$

$$\Phi(SUM)=SUM=-0.816$$

$$

$$\Phi(SUM)=-0.816 < 0 \implies \hat y = -1$$

, .

: $$$t^{(2)}=(t_1^{(2)})=(7)$

$$

$$\Phi(SUM)=SUM= -1.18 + 0.26*7 = 0.64 \geqslant 0 \implies \hat y = 1$$

$$$\hat y = 1$ , .. . .

, ( «» ) 12 . , !

(m=2)

, , , . . , , .

— ( ). 2- .

• $$$x = (x_1, x_2)$ ( , , )
• $$$y = \{-1, 1\}$ ( , )

 #  -  ( ) X1 = np.array([2, 3, 1, 5, 10, 1, 6, 7, 10, 6, 7]) X2 = np.array([1, 1, 2, 2, 3, 5, 6, 6, 7, 8, 8]) #   -   y = np.array([-1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1]) 

 plt.scatter(X1[y == -1], X2[y == -1], s=400, c='red', marker='*', label=u': -1') plt.scatter(X1[y == 1], X2[y == 1], s=200, c='blue', marker='s', label=u': 1') #    #  - -  w0 = -2.7 w1 = .3 w2 = .4 #   ( ) -      =0: # 0=w0+w1*X1+w2*X2 # X2=-(w0+w1*X1)/w2 plt.plot(np.linspace(0,12), -(w0+w1*np.linspace(0,12))/w2, label=u' ') plt.xlim(0, 11) plt.ylim(0, 9) plt.legend(loc='upper left') plt.xlabel('X1') plt.ylabel('X2') plt.show() 

, .

$$

$$\Phi(x, w) = w_0 + w_1 x_1 + w_2 x_2$$

, — , , 1- , 3-:

:

:

— :

() $$$\Phi(w) = 0$ (-). :

, , , , , ( , ). , . , , m=2, (m+1)=3: , — , , — , ( ).

$$

$$J(w)={1 \over 2} SSE = {1 \over 2}\sum_{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)} + w_{2}x_{2}^{(i)} - y^{(i)})^{2}$$

() , .., , 3 + — 4 . , 2- 3- - 3-, , - 4- 3-, .

2- . , , 1- 2-.

$$

$$\nabla J(w)=(\frac{\partial J(w)}{\partial w_{0}}, \frac{\partial J(w)}{\partial w_{1}}, \frac{\partial J(w)}{\partial w_{1}}), w=(w_{0}, w_{1}, w_{2})$$

( ):

$$

$$\frac{\partial J(w)}{\partial w_{0}} =\sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}+w_{2}x_{2}^{(i)}-y^{(i)})$$

$$

$$\frac{\partial J(w)}{\partial w_{1}}= \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}+w_{2}x_{2}^{(i)}-y^{(i)})x_{1}^{(i)}$$

$$

$$\frac{\partial J(w)}{\partial w_{2}}= \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}+w_{2}x_{2}^{(i)}-y^{(i)})x_{2}^{(i)}$$

:

$$

$$\Delta w_{0}=-\eta \frac{\partial J(w)}{\partial w_{0}} =-\eta \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}+w_{2}x_{2}^{(i)}-y^{(i)})$$

$$

$$\Delta w_{1}=-\eta \frac{\partial J(w)}{\partial w_{1}} =-\eta \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}+w_{2}x_{2}^{(i)}-y^{(i)})x_{1}^{(i)}$$

$$

$$\Delta w_{2}=-\eta \frac{\partial J(w)}{\partial w_{2}} =-\eta \sum _{i=1}^{n}(w_{0}+w_{1}x_{1}^{(i)}+w_{2}x_{2}^{(i)}-y^{(i)})x_{2}^{(i)}$$

3- ( 3- ), $$$\eta=0.001$ , $$$w_0=-0.9$ , $$$w_1=-0.9$ , $$$w_2=-0.9$ .

— , , :

:

:

3- - :

4- :

60- — , :

70- , , :

200- — :

400- — :

:

, , $$$w_0$ .

Kode

matplotlib ( mpl_toolkits.mplot3d.axis3d) ( , , 3). Mayavi .

 import numpy from mayavi import mlab #    -   mlab.savefig #mlab.options.offscreen = True #   size    mlab.savefig fig = mlab.figure(fgcolor=(10./256., 10./256., 10./256.), bgcolor=(255./256., 255./256., 255./256.), size=(1650, 950)) X1_ = range(0, 12) X2_ = range(0, 12) XX1_, XX2_ = np.mgrid[X1_, X2_] #    # : color=(255./256., 191./256., 71./256.) # : color=(171./256., 0./256., 130./256.) # : color=(255./256., 101./256., 107./256.) # : color=(252./256., 79./256., 245./256.) # : color=(84./256., 148./256., 247./256.) # : color=(45./256., 0./256., 82./256.) # : color=(254./256., 255./256., 87./256.) #  # : color=(.7, .1, .1) # : color=(.1, .1, .7) #   : =1 (y=1), =-1 (y=-1)    =0 mlab.surf(XX1_, XX2_, np.full((12, 12), -1), color=(255./256., 101./256., 107./256.), opacity=0.6) mlab.surf(XX1_, XX2_, np.full((12, 12), 1), color=(84./256., 148./256., 247./256.), opacity=0.5) mlab.surf(XX1_, XX2_, np.full((12, 12), 0), color=(247./256., 243./256., 246./256.), opacity=0.5) #     # (   , ..      ,   #     :    2- , 3  - #   ,   ) mlab.points3d(X1[y == -1], X2[y == -1], np.full(X1[y == -1].size, 0), color=(.7, .1, .1), mode='sphere', scale_factor=.2) mlab.points3d(X1[y == 1], X2[y == 1], np.full(X1[y == 1].size, 0), color=(.1, .1, .7), mode='cube', scale_factor=.2) #     mlab.points3d(X1[y == -1], X2[y == -1], np.full(X1[y == -1].size, -1), color=(171./256., 0./256., 130./256.), mode='2dcircle', scale_factor=.2) mlab.points3d(X1[y == 1], X2[y == 1], np.full(X1[y == 1].size, 1), color=(45./256., 0./256., 82./256.), mode='2dsquare', scale_factor=.2) #    #      # ... epoch=12 w0=-0.762718 w1=0.165023 w2=0.040271 sse=3.598883 #  -   y=w0+w1*X1+w2*X2 yy_ = w0 + w1*XX1_ + w2*XX2_ actsurf = mlab.surf(XX1_, XX2_, yy_, color=(252./256., 79./256., 245./256.), opacity = 0.6) #       y_ = w0 + w1*X1 + w2*X2 mlab.points3d(X1[y==-1], X2[y==-1], y_[y==-1], color=(171./256., 0./256., 130./256.), mode='sphere', scale_factor=.2) mlab.points3d(X1[y==1], X2[y==1], y_[y==1], color=(45./256., 0./256., 82./256.), mode='cube', scale_factor=.2) #   -       #      for i in range(len(X1[y==-1])): mlab.plot3d( [X1[y==-1][i], X1[y==-1][i]], [X2[y==-1][i], X2[y==-1][i]], [y[y==-1][i], y_[y==-1][i]], color=(255./256., 191./256., 71./256.)) for i in range(len(X1[y==1])): mlab.plot3d( [X1[y==1][i], X1[y==1][i]], [X2[y==1][i], X2[y==1][i]], [y[y==1][i], y_[y==1][i]], color=(255./256., 191./256., 71./256.)) #   -       # (      ) zmin=-2. zmax=2. vis_area = mlab.points3d( [np.min(X1_), np.max(X1_)], [np.min(X2_), np.max(X2_)], [zmin, zmax], mode='point') #          mlab.view( focalpoint=((np.max(X1_)-np.min(X1_))/2, (np.max(X2_)-np.min(X2_))/2, (zmax-zmin)/2), distance=25, azimuth=-50, elevation=75) mlab.move((0,0,10)) #           fig.scene.renderer.use_depth_peeling = 1 #  mlab.outline(vis_area, color=(.7, .7, .7)) #   ,      : -2, -1, 0, 1, 2 axes = mlab.axes(vis_area, nb_labels=5, color=(.7, .7, .7), ranges=[np.min(X1_), np.max(X1_), np.min(X2_), np.max(X2_), zmin, zmax], #xlabel=u'X1', ylabel=u'X2', zlabel=u'(SUM) - ') xlabel=u'X1', ylabel=u'X2', zlabel=u'Phi') #      #from pprint import pprint #pprint(vars(axes)) axes._label_text_property.bold = False axes._label_text_property.italic = False axes._title_text_property.bold = True axes._title_text_property.italic = False #  ,     #axes._title_text_property.font_size = 34 #         : axes.axes.font_factor = .7 #       size  mlab.figure, #        title = mlab.title("epoch=" + str(epoch)) title.actor.text_scale_mode='none' title.property.justification='right' title.property.font_size=48 legend = mlab.text(.6, .8, 'w0=%0.2f, w1=%0.2f, w2=%0.2f, sse/2=%0.6f'%(w0, w1, w2, sse/2)) legend.actor.text_scale_mode='none' legend.property.font_size=18 #   mlab.show() #    #mlab.savefig("epoch" + str(epoch) + ".png") #    :     ,    # (    , , ,  , #    ,     ) #mlab.clf() #mlab.close() #    -      ''' fpoint = ( (np.max(X1_)-np.min(X1_))/2, (np.max(X2_)-np.min(X2_))/2, (zmax-zmin)/2 ) for i in range (0, 360, 2): mlab.view(focalpoint=fpoint, distance=25, elevation=75, azimuth=i) mlab.move((0,0,10)) mlab.savefig("act-2d-azimuth" + str(i) + ".png") ''' 

, Mayavi , . , , , .

Mayavi, Matplotlib/axes3d, 3- OpenGL. , ( ) , Qt. mayavi . pip PyQt5 python-qt (, - , 'qt'). , , , , , :

 env QT_API=pyqt python3 gradient-2d.py 

— $$$J(w)$

 def sse_(X1, X2, y, w0, w1, w2): return ((w0+w1*X1+w2*X2 - y)**2).sum() #      J(w0, w1, w2) #   w0, w1  w2 #   eta = 0.001 #      () epochs = 70 w0_first = -.9 w1_first = -.9 w2_first = -.9 #      w0_epochs = [w0_first] w1_epochs = [w1_first] w2_epochs = [w2_first] delta_w0_epochs = [] delta_w1_epochs = [] delta_w2_epochs = [] w0_next = w0_first w1_next = w1_first w2_next = w2_first for i in range(epochs): grad_w0 = (w0_next + w1_next*X1 + w2_next*X2 - y).sum() delta_w0 = -eta*grad_w0 grad_w1 = ((w0_next + w1_next*X1 + w2_next*X2 - y)*X1).sum() delta_w1 = -eta*grad_w1 grad_w2 = ((w0_next + w1_next*X1 + w2_next*X2 - y)*X2).sum() delta_w2 = -eta*grad_w2 w0_next = w0_next + delta_w0 w1_next = w1_next + delta_w1 w2_next = w2_next + delta_w2 delta_w0_epochs.append(delta_w0) delta_w1_epochs.append(delta_w1) delta_w2_epochs.append(delta_w2) w0_epochs.append(w0_next) w1_epochs.append(w1_next) w2_epochs.append(w2_next) #     sse_epochs = [] for i in range(len(w1_epochs)): sse = sse_(X1, X2, y, w0_epochs[i], w1_epochs[i], w2_epochs[i]) sse_epochs.append(sse) #print('epoch=%d, w0=%f, w1=%f, w2=%f, SSE=%f, SSE/2=%f' % # (i, w0_epochs[i], w1_epochs[i], w2_epochs[i], sse, sse/2)) sse_epochs = np.array(sse_epochs) #  -      η (--) plt.plot(range(len(sse_epochs)), sse_epochs, label=u'J(w)=SSE/2, η=%s'%eta) plt.xlabel(u'epoch (η=%s)'%eta) plt.ylabel(u'J(w)') plt.legend(loc='upper right') plt.show() 

12 :

70 :

, , : 6-12- , 70- — 70- , 30-, 40- 200-, , , , .

Kesimpulan

ADALINE (adaptive linear neuron — ) — . scikit-learn ADALINE ( - , ) , , - « 80-» (ADALINE 60-), .

«Python » ( scikit-learn) , - .

ADALINE .

-, — , : , , , .

-, () , , , ( , , $$$y$ ) — , scikit-learn.

PS , ADALINE . , , , , ADALINE - , . , ADALINE . , - .