อัลกอริทึมการแพร่กระจายกลับ


19

ฉันมีความสับสนเล็กน้อยเกี่ยวกับอัลกอริทึมbackpropagation ที่ใช้ในMultilayer Perceptron (MLP)

ข้อผิดพลาดจะถูกปรับโดยฟังก์ชั่นค่าใช้จ่าย ในการแพร่กระจายย้อนกลับเรากำลังพยายามปรับน้ำหนักของเลเยอร์ที่ซ่อนอยู่ ข้อผิดพลาดของผลลัพธ์ที่ฉันสามารถเข้าใจได้นั่นคือe = d - y[ไม่มีตัวห้อย]

คำถามคือ:

  1. เราจะได้รับข้อผิดพลาดของเลเยอร์ที่ซ่อนอยู่ได้อย่างไร คนเราคำนวณมันได้อย่างไร
  2. ถ้าฉัน backpropagate ฉันควรใช้มันเป็นฟังก์ชั่นต้นทุนของตัวกรองแบบปรับตัวหรือฉันควรใช้ตัวชี้การเขียนโปรแกรม (ใน C / C ++) เพื่อปรับปรุงน้ำหนักหรือไม่

NN เป็นเทคโนโลยีที่ล้าสมัยดังนั้นฉันเกรงว่าคุณจะไม่ได้รับคำตอบเพราะไม่มีใครที่นี่ใช้ ...

@mbq: ฉันไม่สงสัยคำพูดของคุณ แต่คุณจะสรุปได้อย่างไรว่า NN เป็น "เทคโนโลยีล้าสมัย"?
steffen

1
@steffen โดยการสังเกต; ฉันหมายความว่าเห็นได้ชัดว่าไม่มีใครสำคัญจากชุมชน NN จะออกมาและพูดว่า "เฮ้พวกเรามาทิ้งชีวิตของเราและเล่นกับสิ่งที่ดีกว่า!" แต่เรามีเครื่องมือที่บรรลุความถูกต้องเหมือนกันหรือดีกว่าโดยไม่มีความสับสน การฝึกอบรม และผู้คนก็ทำ NN ตกหล่นพวกเขา

5
นี่มีความจริงบางอย่างเมื่อคุณพูดถึง @mbq แต่ไม่ใช่อีกต่อไป
jerad

1
@ Jerad Pretty easy - ฉันไม่ได้เห็นการเปรียบเทียบที่เป็นธรรมกับวิธีการอื่น ๆ (Kaggle ไม่ใช่การเปรียบเทียบที่ยุติธรรมเพราะการขาดช่วงความมั่นใจสำหรับความถูกต้อง - โดยเฉพาะอย่างยิ่งเมื่อผลลัพธ์ของทีมที่ทำคะแนนสูงทั้งหมดอยู่ใกล้มาก เช่นเดียวกับในการแข่งขันของเมอร์ค) การวิเคราะห์ความทนทานของการปรับพารามิเตอร์ให้เหมาะสมนั้นไม่เลวร้ายไปกว่านี้

คำตอบ:


27

ฉันคิดว่าฉันจะตอบโพสต์ในตัวเองที่นี่สำหรับทุกคนที่สนใจ นี้จะมีการใช้สัญกรณ์ที่อธิบายไว้ที่นี่

บทนำ

แนวคิดเบื้องหลัง backpropagation คือมีชุดของ "ตัวอย่างการฝึกอบรม" ที่เราใช้ในการฝึกอบรมเครือข่ายของเรา แต่ละเหล่านี้มีคำตอบที่รู้จักกันดังนั้นเราจึงสามารถเชื่อมต่อพวกเขาเข้ากับเครือข่ายประสาทและพบว่ามันผิดมากแค่ไหน

ตัวอย่างเช่นด้วยการรู้จำลายมือคุณจะมีอักขระที่เขียนด้วยลายมือจำนวนมากพร้อมกับสิ่งที่พวกเขาเป็นจริง จากนั้นเครือข่ายประสาทสามารถฝึกอบรมผ่าน backpropagation เพื่อ "เรียนรู้" วิธีการจดจำสัญลักษณ์แต่ละตัวดังนั้นเมื่อมันถูกนำเสนอในภายหลังด้วยอักขระที่เขียนด้วยลายมือที่ไม่รู้จักมันสามารถระบุสิ่งที่มันถูกต้อง

โดยเฉพาะเราใส่ตัวอย่างการฝึกอบรมลงในเครือข่ายประสาทดูว่ามันทำได้ดีเพียงใดแล้ว "หยดกลับ" เพื่อค้นหาว่าเราสามารถเปลี่ยนน้ำหนักและอคติของโหนดแต่ละโหนดเพื่อให้ได้ผลลัพธ์ที่ดีขึ้นจากนั้นจึงปรับตามนั้น เมื่อเราดำเนินการต่อไปเครือข่าย "เรียนรู้"

นอกจากนี้ยังมีขั้นตอนอื่น ๆ ที่อาจรวมอยู่ในกระบวนการฝึกอบรม (ตัวอย่างเช่นการออกกลางคัน) แต่ฉันจะมุ่งเน้นไปที่ backpropagation เป็นส่วนใหญ่เนื่องจากเป็นสิ่งที่คำถามนี้เกี่ยวกับ

อนุพันธ์บางส่วน

อนุพันธ์ย่อยเป็นอนุพันธ์ของFที่เกี่ยวกับบางตัวแปรxxfx

ตัวอย่างเช่นถ้า , ff(x,y)=x2+y2เพราะปีที่ 2เป็นเพียงการอย่างต่อเนื่องเกี่ยวกับการx เช่นเดียวกันffx=2xy2xเพราะx2เป็นเพียงการอย่างต่อเนื่องเกี่ยวกับการYY=2Yx2Y

การไล่ระดับสีของฟังก์ชันที่กำหนดเป็นฟังก์ชันที่มีอนุพันธ์บางส่วนสำหรับทุกตัวแปรใน f โดยเฉพาะ:

,

f(โวลต์1,โวลต์2,...,โวลต์n)=โวลต์1อี1++โวลต์nอีn

ที่เป็นชี้เวกเตอร์หน่วยในทิศทางของตัวแปรวี 1อีผมโวลต์1

ตอนนี้เมื่อเราได้คำนวณสำหรับฟังก์ชั่นบางถ้าเราอยู่ที่ตำแหน่ง( โวลต์1 , V 2 , . . . , V n )เราสามารถ "สไลด์ลง" โดยไปในทิศทาง- ( โวลต์1 , V 2 , . . . , V n )ff(v1,v2,...,vn)ff(v1,v2,...,vn)

ด้วยตัวอย่างของ , เวกเตอร์หน่วยคือe 1 = ( 1 , 0 )และe 2 = ( 0 , 1 ) , เนื่องจากv 1 = xและv 2 = y , และเวกเตอร์เหล่านั้นชี้ไปในทิศทางของแกนxและy ดังนั้นf ( x , yf(x,y)=x2+y2e1=(1,0)e2=(0,1)v1=xv2=yxy )f(x,y)=2x(1,0)+2y(0,1)

ตอนนี้ที่ "สไลด์ลง" ฟังก์ชั่นของเราสมมติว่าเราอยู่ที่จุด( - 2 , 4 ) จากนั้นเราจะต้องเคลื่อนที่ไปในทิศทาง- f ( - 2 , - 4 ) = - ( 2 - 2 ( 1 , 0 ) + 2 4 ( 0 , 1 ) ) = - ( ( - 4 , 0 ) +f(2,4) )f(2,4)=(22(1,0)+24(0,1))=((4,0)+(0,8))=(4,8)

ขนาดของเวกเตอร์นี้จะทำให้เราเห็นว่าเขาสูงชันแค่ไหน (ค่าที่สูงกว่าหมายถึงเนินเขาสูงชัน) ในกรณีนี้เรามี8.94442+(8)28.944

Gradient Descent

ผลิตภัณฑ์ Hadamard

Hadamard Product ของเมทริกซ์ , ก็เหมือนกับการบวกเมทริกซ์, ยกเว้นแทนที่จะเพิ่มเมทริกซ์องค์ประกอบที่ชาญฉลาด, เราคูณมันกับองค์ประกอบA,BRn×m

อย่างเป็นทางการในขณะที่นอกจากเมทริกซ์เป็น+ B = Cที่C R n × mดังกล่าวว่าA+B=CCRn×m

,

Cji=Aji+Bji

Hadamard สินค้าB = Cที่C R n × mดังกล่าวว่าAB=CCRn×m

Cji=AjiBji

การคำนวณการไล่ระดับสี

(ส่วนใหญ่ส่วนนี้มาจากหนังสือของ Neilsen )

เรามีชุดตัวอย่างการฝึกอบรมโดยที่S rเป็นตัวอย่างการฝึกอบรมอินพุตเดียวและE rคือค่าผลลัพธ์ที่คาดหวังของตัวอย่างการฝึกอบรมนั้น เรายังมีเครือข่ายของเราประสาทประกอบด้วยอคติWและน้ำหนักB rใช้เพื่อป้องกันความสับสนจากi , j , และk ที่ใช้ในการกำหนดเครือข่าย feedforward(S,E)SrErWBrijk

ต่อไปเราจะกำหนดฟังก์ชั่นต้นทุนที่ใช้ในเครือข่ายประสาทของเราและตัวอย่างการฝึกอบรมเดียวC(W,B,Sr,Er)

โดยทั่วไปสิ่งที่ใช้คือต้นทุนกำลังสองซึ่งถูกกำหนดโดย

C(W,B,Sr,Er)=0.5j(ajLEjr)2

ที่Lคือออกไปยังเครือข่ายประสาทของเราได้รับการป้อนข้อมูลตัวอย่างS RaLSr

จากนั้นเราต้องการหาและCCwjiสำหรับแต่ละโหนดในเครือข่ายประสาทของเราคราทCbji

เราสามารถเรียกสิ่งนี้ว่าการไล่ระดับสีของที่เซลล์ประสาทแต่ละอันเพราะเราถือว่าS rและE rเป็นค่าคงที่เนื่องจากเราไม่สามารถเปลี่ยนแปลงพวกมันได้เมื่อเราพยายามเรียนรู้ และนี่ก็สมเหตุสมผล - เราต้องการเคลื่อนที่ในทิศทางที่สัมพันธ์กับWและBที่ลดต้นทุนลงและเคลื่อนที่ในทิศทางลบของการไล่ระดับสีเทียบกับWและBจะทำเช่นนี้CSrErWBWB

การทำเช่นนี้เรากำหนดเป็นข้อผิดพลาดของเซลล์ประสาทในชั้นฉันδji=Czjiji

เราเริ่มต้นด้วยการคำนวณLโดยเสียบS Rเข้าสู่เครือข่ายประสาทของเราaLSr

จากนั้นเราคำนวณผิดพลาดของชั้นผลผลิตของเราที่ผ่านδL

)

δjL=CajLσ(zjL)

ซึ่งยังสามารถเขียนเป็น

)

δL=aCσ(zL)

ต่อไปเราจะพบข้อผิดพลาดในแง่ของข้อผิดพลาดในชั้นถัดไปδ ฉัน+ 1ผ่านδiδi+1

δi=((Wi+1)Tδi+1)σ(zi)

ตอนนี้เรามีข้อผิดพลาดของแต่ละโหนดในเครือข่ายประสาทของเราการคำนวณการไล่ระดับสีที่เกี่ยวกับน้ำหนักและอคติของเรานั้นง่าย:

Cwjki=δjiaki1=δi(ai1)T

Cbji=δji

โปรดทราบว่าสมการสำหรับข้อผิดพลาดของเลเยอร์เอาท์พุทเป็นสมการเดียวที่ขึ้นอยู่กับฟังก์ชันต้นทุนดังนั้นไม่ว่าฟังก์ชันต้นทุนจะเป็นสมการสามประการสุดท้ายที่เหมือนกัน

ตัวอย่างเช่นเรามีค่ากำลังสอง

δL=(aLEr)σ(zL)

for the error of the output layer. and then this equation can be plugged into the second equation to get the error of the L1th layer:

δL1=((WL)TδL)σ(zL1)
=((WL)T((aLEr)σ(zL)))σ(zL1)

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 δji=Czji 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" η.

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

Δwjki=ηCwjki

Δbji=ηCbji

Thus, our new weights and biases are

wjki=wjki+Δwjki
bji=bji+Δbji

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

Δwjki=1nrΔwjkri

and

Δbji=1nrΔbjri

where Δwjkri is the computed change in weight for sample r, and Δbjri is the computed change in bias for sample r.

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

wjki=wjki+Δwjki
bji=bji+Δbji

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.


6

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.

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.