Saya mendapat sedikit kebingungan pada algoritma backpropagation yang digunakan dalam multilayer perceptron (MLP).

Kesalahan disesuaikan dengan fungsi biaya. Dalam backpropagation, kami mencoba untuk menyesuaikan berat lapisan yang tersembunyi. Kesalahan keluaran yang bisa saya mengerti, yaitu, e = d - y[Tanpa subskrip].

Pertanyaannya adalah:

Bagaimana cara mendapatkan kesalahan dari lapisan tersembunyi? Bagaimana cara menghitungnya?
Jika saya melakukan backpropagate, haruskah saya menggunakannya sebagai fungsi biaya dari filter adaptif atau haruskah saya menggunakan pointer (dalam C / C ++) pengertian pemrograman, untuk memperbarui bobot?

machine-learning neural-networks backpropagation

— HIGGIN
sumber

NN adalah teknologi yang agak ketinggalan zaman, jadi saya khawatir Anda tidak akan mendapatkan jawaban karena tidak ada orang di sini yang menggunakannya ...

@ MBb: Saya tidak meragukan kata-kata Anda, tetapi bagaimana Anda sampai pada kesimpulan bahwa NN adalah "teknologi usang"?

— steffen

@steffen Dengan observasi; Maksud saya jelas bahwa tidak ada seorang pun yang signifikan dari komunitas NN yang akan keluar dan berkata, "Hai teman-teman, mari kita lepaskan pekerjaan seumur hidup kita dan bermain dengan sesuatu yang lebih baik!", Tetapi kita memiliki alat yang mencapai akurasi yang sama atau lebih baik tanpa semua ambivalensi ini dan tidak pernah pelatihan -akhir. Dan orang-orang menjatuhkan NN mendukung mereka.

Ini memiliki beberapa kebenaran ketika Anda mengatakannya, @ MBQ, tetapi tidak lagi.

— jerad

@ Jerad Cukup mudah - Saya belum melihat perbandingan yang adil dengan metode lain (Kaggle bukan perbandingan yang adil karena kurangnya interval kepercayaan untuk akurasi - terutama ketika hasil dari semua tim dengan skor tinggi sangat dekat seperti dalam kontes Merck), tidak ada analisis kekokohan optimasi parameter - yang jauh lebih buruk.

Saya pikir saya akan menjawab posting mandiri di sini untuk siapa saja yang tertarik. Ini akan menggunakan notasi yang dijelaskan di sini .

pengantar

Gagasan di balik backpropagation adalah untuk memiliki satu set "contoh pelatihan" yang kami gunakan untuk melatih jaringan kami. Masing-masing memiliki jawaban yang diketahui, sehingga kita dapat menyambungkannya ke jaringan saraf dan menemukan seberapa banyak kesalahannya.

Misalnya, dengan pengenalan tulisan tangan, Anda akan memiliki banyak karakter tulisan tangan di samping apa sebenarnya mereka. Kemudian jaringan saraf dapat dilatih melalui backpropagation untuk "belajar" bagaimana mengenali masing-masing simbol, jadi ketika itu kemudian disajikan dengan karakter tulisan tangan yang tidak dikenal itu dapat mengidentifikasi apa itu dengan benar.

Secara khusus, kami memasukkan beberapa sampel pelatihan ke jaringan saraf, melihat seberapa baik itu, kemudian "menetes ke belakang" untuk menemukan seberapa banyak kita dapat mengubah bobot dan bias masing-masing node untuk mendapatkan hasil yang lebih baik, dan kemudian menyesuaikannya. Ketika kami terus melakukan ini, jaringan "belajar".

Ada juga langkah-langkah lain yang mungkin termasuk dalam proses pelatihan (misalnya, putus sekolah), tetapi saya akan lebih fokus pada backpropagation karena memang itulah pertanyaannya.

Derivatif parsial

Turunan parsial adalah turunan darisehubungan dengan beberapa variabel. $\frac{\partial f}{\partial x}$ $f$ $x$

Misalnya, jika , $f(x, y)=x^2 + y^2$ , karenahanyalah sebuah konstanta sehubungan dengan. Demikian juga, $\frac{\partial f}{\partial x}=2x$ $y^2$ $x$ , karenahanyalah sebuah konstanta sehubungan dengan $\frac{\partial f}{\partial y}= 2y$ $x^2$ . $y$

Gradien suatu fungsi, yang ditunjuk $\nabla f$ , adalah fungsi yang mengandung turunan parsial untuk setiap variabel dalam f. Secara khusus:

\nabla f (v_{1}, v_{2}, . . ., v_{n}) = \frac{\partial f}{\partial v_{1}} e_{1} + \dots + \frac{\partial f}{\partial v_{n}} e_{n}

$\nabla f(v_1, v_2, ..., v_n) = \frac{\partial f}{\partial v_1 }\mathbf{e}_1 + \cdots + \frac{\partial f}{\partial v_n }\mathbf{e}_n$

di mana adalah vektor satuan yang menunjuk ke arah variabel $e_i$ . $v_1$

Sekarang, setelah kami telah dihitung dengan untuk beberapa fungsi , jika kita berada di posisi , kita bisa "slide down" dengan pergi ke arah . $\nabla f$ $f$ $(v_1, v_2, ..., v_n)$ $f$ $-\nabla f(v_1, v_2, ..., v_n)$

Dengan contoh , vektor satuan adalah dan , karena dan , dan vektor-vektor itu menunjuk ke arah sumbu dan . Dengan demikian, $f(x, y)=x^2 + y^2$ $e_1=(1, 0)$ $e_2=(0, 1)$ $v_1=x$ $v_2=y$ $x$ $y$ . $\nabla f(x, y) = 2x (1, 0) + 2y(0, 1)$

Sekarang, untuk "geser ke bawah" fungsi kita , katakanlah kita berada pada suatu titik . Maka kita perlu bergerak ke arah $f$ $(-2, 4)$ . $-\nabla f(-2, -4)= -(2 \cdot -2 \cdot (1, 0) + 2 \cdot 4 \cdot (0, 1)) = -((-4, 0) + (0, 8))=(4, -8)$

Besarnya vektor ini akan memberi kita seberapa curam bukit itu (nilai yang lebih tinggi berarti bukit lebih curam). Dalam hal ini, kami punya $\sqrt{4^2+(-8)^2}\approx 8.944$ .

Gradient Descent

Produk Hadamard

Produk Hadamard dari dua matriks $A, B \in R^{n\times m}$ , sama seperti penambahan matriks, kecuali alih-alih menambahkan elemen matriks, kami mengalikannya dengan elemen.

Secara formal, sedangkan penambahan matriks adalah , di mana $A + B = C$ $C \in R^{n \times m}$ sedemikian rupa

C_{j}^{i} = A_{j}^{i} + B_{j}^{i}

$C^i_j = A^i_j + B^i_j$ ,

Produk Hadamard , di mana sedemikian rupa $A \odot B = C$ $C \in R^{n \times m}$

C_{j}^{i} = A_{j}^{i} \cdot B_{j}^{i}

$C^i_j = A^i_j \cdot B^i_j$

Komputasi gradien

(sebagian besar bagian ini dari buku Neilsen ).

Kami memiliki satu set sampel pelatihan, , dimana adalah contoh pelatihan input tunggal, dan adalah nilai output yang diharapkan dari sampel pelatihan. Kami juga memiliki jaringan kami saraf, terdiri dari bias , dan bobot . digunakan untuk mencegah kebingungan dari , , dan $(S, E)$ $S_r$ $E_r$ $W$ $B$ $r$ $i$ $j$ $k$ digunakan dalam definisi jaringan feedforward.

Selanjutnya, kita mendefinisikan fungsi biaya, $C(W, B, S^r, E^r)$ yang mengambil jaringan saraf kita dan contoh pelatihan tunggal, dan menampilkan seberapa baik .

Biasanya yang digunakan adalah biaya kuadratik, yang didefinisikan oleh

C (W, B, S^{r}, E^{r}) = 0.5 \sum_{j} (a_{j}^{L} - E_{j}^{r})^{2}

$C(W, B, S^r, E^r) = 0.5\sum\limits_j (a^L_j - E^r_j)^2$

di mana adalah output ke jaringan saraf kami, mengingat masukan sampel $a^L$ $S^r$

Kemudian kami ingin mencari dan $\frac{\partial C}{\partial w^i_j}$ $\frac{\partial C}{\partial b^i_j}$ untuk setiap node dalam jaringan saraf umpan maju kami.

Kita bisa menyebutnya gradien pada setiap neuron karena kita menganggap dan sebagai konstanta, karena kita tidak bisa mengubah mereka ketika kita mencoba untuk belajar. Dan ini masuk akal - kami ingin bergerak ke arah relatif ke dan yang meminimalkan biaya, dan bergerak ke arah negatif gradien sehubungan dengan dan akan melakukan ini. $C$ $S^r$ $E^r$ $W$ $B$ $W$ $B$

Untuk melakukan ini, kita mendefinisikan sebagai kesalahan neurondi lapisan $\delta^i_j=\frac{\partial C}{\partial z^i_j}$ $j$ $i$ .

Kita mulai dengan menghitung dengan cara menghubungkan $a^L$ $S^r$ ke jaringan saraf kita.

Kemudian kami menghitung kesalahan dari layer output kami, , via $\delta^L$

δ_{j}^{L} = \frac{\partial C}{\partial a_{j}^{L}} σ^{'} (z_{j}^{L})

$\delta^L_j = \frac{\partial C}{\partial a^L_j} \sigma^{ \prime}(z^L_j)$

Yang juga bisa ditulis sebagai

δ^{L} = \nabla_{a} C ⊙ σ^{'} (z^{L})

$\delta^L = \nabla_a C \odot \sigma^{ \prime}(z^L)$ .

Next, we find the error $\delta^i$ in terms of the error in the next layer $\delta^{i+1}$ , via

δ^{i} = ((W^{i + 1})^{T} δ^{i + 1}) ⊙ σ^{'} (z^{i})

$\delta^i=((W^{i+1})^T \delta^{i+1}) \odot \sigma^{\prime}(z^i)$

Sekarang kita memiliki kesalahan dari setiap node di jaringan saraf kita, menghitung gradien sehubungan dengan bobot dan bias kita mudah:

\frac{\partial C}{\partial w_{j k}^{i}} = δ_{j}^{i} a_{k}^{i - 1} = δ^{i} (a^{i - 1})^{T}

$\frac{\partial C}{\partial w^i_{jk}}=\delta^i_j a^{i-1}_k=\delta^i(a^{i-1})^T$

\frac{\partial C}{\partial b_{j}^{i}} = δ_{j}^{i}

$\frac{\partial C}{\partial b^i_j} = \delta^i_j$

Note that the equation for the error of the output layer is the only equation that's dependent on the cost function, so, regardless of the cost function, the last three equations are the same.

As an example, with quadratic cost, we get

δ^{L} = (a^{L} - E^{r}) ⊙ σ^{'} (z^{L})

$\delta ^L = (a^L - E^r) \odot \sigma ^ {\prime}(z^L)$

for the error of the output layer. and then this equation can be plugged into the second equation to get the error of the $L-1^{\text{th}}$ layer:

δ^{L - 1} = ((W^{L})^{T} δ^{L}) ⊙ σ^{'} (z^{L - 1})

$\delta^{L-1}=((W^{L})^T \delta^{L}) \odot \sigma^{\prime}(z^{L-1})$

= ((W^{L})^{T} ((a^{L} - E^{r}) ⊙ σ^{'} (z^{L}))) ⊙ σ^{'} (z^{L - 1})

$=((W^{L})^T ((a^L - E^r) \odot \sigma ^ {\prime}(z^L))) \odot \sigma^{\prime}(z^{L-1})$

which we can repeat this process to find the error of any layer with respect to $C$ , which then allows us to compute the gradient of any node's weights and bias with respect to $C$ .

I could write up an explanation and proof of these equations if desired, though one can also find proofs of them here. I'd encourage anyone that is reading this to prove these themselves though, beginning with the definition $\delta^i_j=\frac{\partial C}{\partial z^i_j}$ and applying the chain rule liberally.

For some more examples, I made a list of some cost functions alongside their gradients here.

Gradient Descent

Now that we have these gradients, we need to use them learn. In the previous section, we found how to move to "slide down" the curve with respect to some point. In this case, because it's a gradient of some node with respect to weights and a bias of that node, our "coordinate" is the current weights and bias of that node. Since we've already found the gradients with respect to those coordinates, those values are already how much we need to change.

We don't want to slide down the slope at a very fast speed, otherwise we risk sliding past the minimum. To prevent this, we want some "step size" $\eta$ .

Then, find the how much we should modify each weight and bias by, because we have already computed the gradient with respect to the current we have

Δ w_{j k}^{i} = - η \frac{\partial C}{\partial w_{j k}^{i}}

$\Delta w^i_{jk}= -\eta \frac{\partial C}{\partial w^i_{jk}}$

Δ b_{j}^{i} = - η \frac{\partial C}{\partial b_{j}^{i}}

$\Delta b^i_j = -\eta \frac{\partial C}{\partial b^i_j}$

Thus, our new weights and biases are

w_{j k}^{i} = w_{j k}^{i} + Δ w_{j k}^{i}

$w^i_{jk} = w^i_{jk} + \Delta w^i_{jk}$

b_{j}^{i} = b_{j}^{i} + Δ b_{j}^{i}

$b^i_j = b^i_j + \Delta b^i_j$

Using this process on a neural network with only an input layer and an output layer is called the Delta Rule.

Stochastic Gradient Descent

Now that we know how to perform backpropagation for a single sample, we need some way of using this process to "learn" our entire training set.

One option is simply performing backpropagation for each sample in our training data, one at a time. This is pretty inefficient though.

A better approach is Stochastic Gradient Descent. Instead of performing backpropagation for each sample, we pick a small random sample (called a batch) of our training set, then perform backpropagation for each sample in that batch. The hope is that by doing this, we capture the "intent" of the data set, without having to compute the gradient of every sample.

For example, if we had 1000 samples, we could pick a batch of size 50, then run backpropagation for each sample in this batch. The hope is that we were given a large enough training set that it represents the distribution of the actual data we are trying to learn well enough that picking a small random sample is sufficient to capture this information.

However, doing backpropagation for each training example in our mini-batch isn't ideal, because we can end up "wiggling around" where training samples modify weights and biases in such a way that they cancel each other out and prevent them from getting to the minimum we are trying to get to.

To prevent this, we want to go to the "average minimum," because the hope is that, on average, the samples' gradients are pointing down the slope. So, after choosing our batch randomly, we create a mini-batch which is a small random sample of our batch. Then, given a mini-batch with $n$ training samples, and only update the weights and biases after averaging the gradients of each sample in the mini-batch.

Formally, we do

Δ w_{j k}^{i} = \frac{1}{n} \sum_{r} Δ w_{j k}^{r i}

$\Delta w^{i}_{jk} = \frac{1}{n}\sum\limits_r \Delta w^{ri}_{jk}$

and

Δ b_{j}^{i} = \frac{1}{n} \sum_{r} Δ b_{j}^{r i}

$\Delta b^{i}_{j} = \frac{1}{n}\sum\limits_r \Delta b^{ri}_{j}$

where $\Delta w^{ri}_{jk}$ is the computed change in weight for sample $r$ , and $\Delta b^{ri}_{j}$ is the computed change in bias for sample $r$ .

Then, like before, we can update the weights and biases via:

w_{j k}^{i} = w_{j k}^{i} + Δ w_{j k}^{i}

$w^i_{jk} = w^i_{jk} + \Delta w^{i}_{jk}$

b_{j}^{i} = b_{j}^{i} + Δ b_{j}^{i}

$b^i_j = b^i_j + \Delta b^{i}_{j}$

This gives us some flexibility in how we want to perform gradient descent. If we have a function we are trying to learn with lots of local minima, this "wiggling around" behavior is actually desirable, because it means that we're much less likely to get "stuck" in one local minima, and more likely to "jump out" of one local minima and hopefully fall in another that is closer to the global minima. Thus we want small mini-batches.

On the other hand, if we know that there are very few local minima, and generally gradient descent goes towards the global minima, we want larger mini-batches, because this "wiggling around" behavior will prevent us from going down the slope as fast as we would like. See here.

One option is to pick the largest mini-batch possible, considering the entire batch as one mini-batch. This is called Batch Gradient Descent, since we are simply averaging the gradients of the batch. This is almost never used in practice, however, because it is very inefficient.

— Phylliida
sumber

I haven't dealt with Neural Networks for some years now, but I think you will find everything you need here:

Neural Networks - A Systematic Introduction, Chapter 7: The backpropagation algorithm

I apologize for not writing the direct answer here, but since I have to look up the details to remember (like you) and given that the answer without some backup may be even useless, I hope this is ok. However, if any questions remain, drop a comment and I'll see what I can do.

— steffen
sumber

Algoritma backpropagation

pengantar

Derivatif parsial

Produk Hadamard

Komputasi gradien

Gradient Descent

Stochastic Gradient Descent