การเรียนรู้ภายใต้การดูแล
ตามชื่อ supervised learningเกิดขึ้นภายใต้การดูแลของครู กระบวนการเรียนรู้นี้ขึ้นอยู่กับ ในระหว่างการฝึก ANN ภายใต้การเรียนรู้ภายใต้การดูแลเวกเตอร์อินพุตจะถูกนำเสนอไปยังเครือข่ายซึ่งจะสร้างเวกเตอร์เอาต์พุต เวกเตอร์เอาต์พุตนี้เปรียบเทียบกับเวกเตอร์เอาต์พุตที่ต้องการ / เป้าหมาย สัญญาณข้อผิดพลาดจะถูกสร้างขึ้นหากมีความแตกต่างระหว่างเอาต์พุตจริงและเวกเตอร์เอาต์พุตที่ต้องการ / เป้าหมาย บนพื้นฐานของสัญญาณข้อผิดพลาดนี้น้ำหนักจะถูกปรับจนกว่าเอาต์พุตจริงจะตรงกับเอาต์พุตที่ต้องการ
เพอร์เซปตรอน
พัฒนาโดย Frank Rosenblatt โดยใช้แบบจำลอง McCulloch และ Pitts perceptron เป็นหน่วยปฏิบัติการพื้นฐานของโครงข่ายประสาทเทียม ใช้กฎการเรียนรู้ภายใต้การดูแลและสามารถจำแนกข้อมูลออกเป็นสองชั้น
ลักษณะการทำงานของเพอร์เซปตรอน: ประกอบด้วยเซลล์ประสาทเดียวที่มีจำนวนอินพุตตามอำเภอใจพร้อมกับน้ำหนักที่ปรับได้ แต่เอาต์พุตของเซลล์ประสาทคือ 1 หรือ 0 ขึ้นอยู่กับเกณฑ์ นอกจากนี้ยังประกอบด้วยอคติที่มีน้ำหนักเสมอ 1 รูปต่อไปนี้ให้การแสดงแผนผังของเพอร์เซปตรอน
Perceptron จึงมีองค์ประกอบพื้นฐานสามประการดังต่อไปนี้ -
Links - มันจะมีชุดของลิงค์การเชื่อมต่อซึ่งมีน้ำหนักรวมถึงอคติที่มีน้ำหนักเสมอ 1
Adder - เพิ่มอินพุตหลังจากคูณด้วยน้ำหนักตามลำดับ
Activation function- มัน จำกัด การส่งออกของเซลล์ประสาท ฟังก์ชันการเปิดใช้งานขั้นพื้นฐานที่สุดคือฟังก์ชันขั้นตอน Heaviside ที่มีเอาต์พุตที่เป็นไปได้สองแบบ ฟังก์ชันนี้จะคืนค่า 1 หากอินพุตเป็นบวกและ 0 สำหรับอินพุตเชิงลบใด ๆ
อัลกอริทึมการฝึกอบรม
สามารถฝึกเครือข่าย Perceptron สำหรับยูนิตเอาต์พุตเดี่ยวและยูนิตเอาต์พุตหลายยูนิต
อัลกอริทึมการฝึกอบรมสำหรับหน่วยเอาต์พุตเดี่ยว
Step 1 - เริ่มต้นสิ่งต่อไปนี้เพื่อเริ่มการฝึกอบรม -
- Weights
- Bias
- อัตราการเรียนรู้ $ \ alpha $
เพื่อการคำนวณที่ง่ายและเรียบง่ายต้องกำหนดน้ำหนักและอคติให้เท่ากับ 0 และต้องกำหนดอัตราการเรียนรู้ให้เท่ากับ 1
Step 2 - ทำตามขั้นตอนที่ 3-8 ต่อเมื่อเงื่อนไขการหยุดไม่เป็นจริง
Step 3 - ทำต่อขั้นตอนที่ 4-6 สำหรับเวกเตอร์การฝึกทุกตัว x.
Step 4 - เปิดใช้งานหน่วยอินพุตแต่ละหน่วยดังนี้ -
$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: ถึง \: n) $$
Step 5 - ตอนนี้รับอินพุตสุทธิด้วยความสัมพันธ์ต่อไปนี้ -
$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ LIMIT_ {i} ^ n x_ {i}. \: w_ {i} $$
ที่นี่ ‘b’ เป็นอคติและ ‘n’ คือจำนวนเซลล์ประสาทอินพุตทั้งหมด
Step 6 - ใช้ฟังก์ชันการเปิดใช้งานต่อไปนี้เพื่อรับผลลัพธ์สุดท้าย
$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {in} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {in} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {in} \: <\: - \ theta \ end {cases} $$
Step 7 - ปรับน้ำหนักและอคติดังนี้ -
Case 1 - ถ้า y ≠ t จากนั้น
$$ w_ {i} (ใหม่) \: = \: w_ {i} (เก่า) \: + \: \ alpha \: tx_ {i} $$
$$ b (ใหม่) \: = \: b (เก่า) \: + \: \ alpha t $$
Case 2 - ถ้า y = t จากนั้น
$$ w_ {i} (ใหม่) \: = \: w_ {i} (เก่า) $$
$$ b (ใหม่) \: = \: b (เก่า) $$
ที่นี่ ‘y’ คือผลลัพธ์จริงและ ‘t’ คือผลลัพธ์ที่ต้องการ / เป้าหมาย
Step 8 - ทดสอบสภาพการหยุดซึ่งจะเกิดขึ้นเมื่อไม่มีการเปลี่ยนแปลงของน้ำหนัก
อัลกอริทึมการฝึกอบรมสำหรับหน่วยเอาต์พุตหลายหน่วย
แผนภาพต่อไปนี้เป็นสถาปัตยกรรมของ perceptron สำหรับเอาต์พุตหลายคลาส
Step 1 - เริ่มต้นสิ่งต่อไปนี้เพื่อเริ่มการฝึกอบรม -
- Weights
- Bias
- อัตราการเรียนรู้ $ \ alpha $
เพื่อการคำนวณที่ง่ายและเรียบง่ายต้องกำหนดน้ำหนักและอคติให้เท่ากับ 0 และต้องกำหนดอัตราการเรียนรู้ให้เท่ากับ 1
Step 2 - ทำตามขั้นตอนที่ 3-8 ต่อเมื่อเงื่อนไขการหยุดไม่เป็นจริง
Step 3 - ทำต่อขั้นตอนที่ 4-6 สำหรับเวกเตอร์การฝึกทุกตัว x.
Step 4 - เปิดใช้งานหน่วยอินพุตแต่ละหน่วยดังนี้ -
$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: ถึง \: n) $$
Step 5 - รับอินพุตสุทธิด้วยความสัมพันธ์ต่อไปนี้ -
$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ LIMIT_ {i} ^ n x_ {i} \: w_ {ij} $$
ที่นี่ ‘b’ เป็นอคติและ ‘n’ คือจำนวนเซลล์ประสาทอินพุตทั้งหมด
Step 6 - ใช้ฟังก์ชันการเปิดใช้งานต่อไปนี้เพื่อรับเอาต์พุตสุดท้ายสำหรับเอาต์พุตแต่ละยูนิต j = 1 to m -
$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {อันตราย} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {อันตราย} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {อันตราย} \: <\: - \ theta \ end {cases} $$
Step 7 - ปรับน้ำหนักและอคติสำหรับ x = 1 to n และ j = 1 to m ดังต่อไปนี้ -
Case 1 - ถ้า yj ≠ tj จากนั้น
$$ w_ {ij} (ใหม่) \: = \: w_ {ij} (เก่า) \: + \: \ alpha \: t_ {j} x_ {i} $$
$$ b_ {j} (ใหม่) \: = \: b_ {j} (เก่า) \: + \: \ alpha t_ {j} $$
Case 2 - ถ้า yj = tj จากนั้น
$$ w_ {ij} (ใหม่) \: = \: w_ {ij} (เก่า) $$
$$ b_ {j} (ใหม่) \: = \: b_ {j} (เก่า) $$
ที่นี่ ‘y’ คือผลลัพธ์จริงและ ‘t’ คือผลลัพธ์ที่ต้องการ / เป้าหมาย
Step 8 - ทดสอบสภาพการหยุดซึ่งจะเกิดขึ้นเมื่อไม่มีการเปลี่ยนแปลงของน้ำหนัก
เซลล์ประสาทเชิงเส้นปรับตัว (Adaline)
Adaline ซึ่งย่อมาจาก Adaptive Linear Neuron คือเครือข่ายที่มีหน่วยเชิงเส้นเดียว ได้รับการพัฒนาโดย Widrow and Hoff ในปี 1960 จุดสำคัญบางประการเกี่ยวกับ Adaline มีดังนี้ -
ใช้ฟังก์ชันการเปิดใช้งานสองขั้ว
ใช้กฎเดลต้าสำหรับการฝึกอบรมเพื่อลดข้อผิดพลาด Mean-Squared Error (MSE) ระหว่างเอาต์พุตจริงและเอาต์พุตที่ต้องการ / เป้าหมาย
น้ำหนักและอคติสามารถปรับได้
สถาปัตยกรรม
โครงสร้างพื้นฐานของ Adaline นั้นคล้ายกับ perceptron ที่มีลูปข้อเสนอแนะพิเศษซึ่งจะเปรียบเทียบผลลัพธ์จริงกับเอาต์พุตที่ต้องการ / เป้าหมาย หลังจากเปรียบเทียบบนพื้นฐานของอัลกอริทึมการฝึกแล้วน้ำหนักและอคติจะได้รับการอัปเดต
อัลกอริทึมการฝึกอบรม
Step 1 - เริ่มต้นสิ่งต่อไปนี้เพื่อเริ่มการฝึกอบรม -
- Weights
- Bias
- อัตราการเรียนรู้ $ \ alpha $
เพื่อการคำนวณที่ง่ายและเรียบง่ายต้องกำหนดน้ำหนักและอคติให้เท่ากับ 0 และต้องกำหนดอัตราการเรียนรู้ให้เท่ากับ 1
Step 2 - ทำตามขั้นตอนที่ 3-8 ต่อเมื่อเงื่อนไขการหยุดไม่เป็นจริง
Step 3 - ทำขั้นตอนที่ 4-6 ต่อสำหรับคู่ฝึกไบโพลาร์ทุกคู่ s:t.
Step 4 - เปิดใช้งานหน่วยอินพุตแต่ละหน่วยดังนี้ -
$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: ถึง \: n) $$
Step 5 - รับอินพุตสุทธิด้วยความสัมพันธ์ต่อไปนี้ -
$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ LIMIT_ {i} ^ n x_ {i} \: w_ {i} $$
ที่นี่ ‘b’ เป็นอคติและ ‘n’ คือจำนวนเซลล์ประสาทอินพุตทั้งหมด
Step 6 - ใช้ฟังก์ชันการเปิดใช้งานต่อไปนี้เพื่อรับผลลัพธ์สุดท้าย -
$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {in} \: \ geqslant \: 0 \\ - 1 & if \: y_ {in} \: < \: 0 \ end {cases} $$
Step 7 - ปรับน้ำหนักและอคติดังนี้ -
Case 1 - ถ้า y ≠ t จากนั้น
$$ w_ {i} (ใหม่) \: = \: w_ {i} (เก่า) \: + \: \ alpha (t \: - \: y_ {in}) x_ {i} $$
$$ b (ใหม่) \: = \: b (เก่า) \: + \: \ alpha (t \: - \: y_ {in}) $$
Case 2 - ถ้า y = t จากนั้น
$$ w_ {i} (ใหม่) \: = \: w_ {i} (เก่า) $$
$$ b (ใหม่) \: = \: b (เก่า) $$
ที่นี่ ‘y’ คือผลลัพธ์จริงและ ‘t’ คือผลลัพธ์ที่ต้องการ / เป้าหมาย
$ (t \: - \; y_ {in}) $ คือข้อผิดพลาดในการคำนวณ
Step 8 - ทดสอบสภาพการหยุดซึ่งจะเกิดขึ้นเมื่อไม่มีการเปลี่ยนแปลงของน้ำหนักหรือการเปลี่ยนแปลงของน้ำหนักสูงสุดที่เกิดขึ้นระหว่างการฝึกซ้อมมีค่าน้อยกว่าค่าเผื่อที่กำหนด
เซลล์ประสาทเชิงเส้นปรับตัวหลายตัว (Madaline)
Madaline ซึ่งย่อมาจาก Multiple Adaptive Linear Neuron เป็นเครือข่ายที่ประกอบด้วย Adalines จำนวนมากควบคู่กัน มันจะมีหน่วยเอาท์พุตเดียว ประเด็นสำคัญบางประการเกี่ยวกับ Madaline มีดังนี้ -
มันเหมือนกับ Perceptron หลายชั้นโดยที่ Adaline จะทำหน้าที่เป็นหน่วยที่ซ่อนอยู่ระหว่างอินพุตและเลเยอร์ Madaline
น้ำหนักและความลำเอียงระหว่างชั้นอินพุตและชั้นอะดาไลน์ตามที่เราเห็นในสถาปัตยกรรม Adaline สามารถปรับได้
ชั้น Adaline และ Madaline มีน้ำหนักและอคติคงที่เท่ากับ 1
การฝึกอบรมสามารถทำได้ด้วยความช่วยเหลือของกฎเดลต้า
สถาปัตยกรรม
สถาปัตยกรรมของ Madaline ประกอบด้วย “n” เซลล์ประสาทของชั้นอินพุต “m”เซลล์ประสาทของชั้น Adaline และ 1 เซลล์ประสาทของชั้น Madaline ชั้น Adaline ถือได้ว่าเป็นชั้นที่ซ่อนอยู่เนื่องจากอยู่ระหว่างชั้นอินพุตและชั้นเอาต์พุตนั่นคือชั้น Madaline
อัลกอริทึมการฝึกอบรม
ถึงตอนนี้เรารู้แล้วว่าต้องปรับเฉพาะน้ำหนักและอคติระหว่างชั้นอินพุตและชั้นอะดาลีนและน้ำหนักและอคติระหว่างชั้นอะดาลีนและชั้นมาดาไลน์ได้รับการแก้ไข
Step 1 - เริ่มต้นสิ่งต่อไปนี้เพื่อเริ่มการฝึกอบรม -
- Weights
- Bias
- อัตราการเรียนรู้ $ \ alpha $
เพื่อการคำนวณที่ง่ายและเรียบง่ายต้องกำหนดน้ำหนักและอคติให้เท่ากับ 0 และต้องกำหนดอัตราการเรียนรู้ให้เท่ากับ 1
Step 2 - ทำตามขั้นตอนที่ 3-8 ต่อเมื่อเงื่อนไขการหยุดไม่เป็นจริง
Step 3 - ทำขั้นตอนที่ 4-6 ต่อสำหรับคู่ฝึกไบโพลาร์ทุกคู่ s:t.
Step 4 - เปิดใช้งานหน่วยอินพุตแต่ละหน่วยดังนี้ -
$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: ถึง \: n) $$
Step 5 - รับอินพุตสุทธิในแต่ละชั้นที่ซ่อนอยู่นั่นคือชั้น Adaline ที่มีความสัมพันธ์ดังต่อไปนี้ -
$$ Q_ {อันตราย} \: = \: b_ {j} \: + \: \ displaystyle \ sum \ LIMIT_ {i} ^ n x_ {i} \: w_ {ij} \: \: \: j \: = \: 1 \: ถึง \: m $$
ที่นี่ ‘b’ เป็นอคติและ ‘n’ คือจำนวนเซลล์ประสาทอินพุตทั้งหมด
Step 6 - ใช้ฟังก์ชันการเปิดใช้งานต่อไปนี้เพื่อให้ได้ผลลัพธ์สุดท้ายที่ชั้น Adaline และชั้น Madaline -
$$ f (x) \: = \: \ begin {cases} 1 & if \: x \: \ geqslant \: 0 \\ - 1 & if \: x \: <\: 0 \ end {cases} $ $
เอาท์พุทที่หน่วย (Adaline) ที่ซ่อนอยู่
$$ Q_ {j} \: = \: f (Q_ {อันตราย}) $$
ผลลัพธ์สุดท้ายของเครือข่าย
$$ y \: = \: f (y_ {in}) $$
i.e. $ \: \: y_ {อันตราย} \: = \: b_ {0} \: + \: \ sum_ {j = 1} ^ m \: Q_ {j} \: v_ {j} $
Step 7 - คำนวณข้อผิดพลาดและปรับน้ำหนักดังนี้ -
Case 1 - ถ้า y ≠ t และ t = 1 จากนั้น
$$ w_ {ij} (ใหม่) \: = \: w_ {ij} (เก่า) \: + \: \ alpha (1 \: - \: Q_ {อันตราย}) x_ {i} $$
$$ b_ {j} (ใหม่) \: = \: b_ {j} (เก่า) \: + \: \ alpha (1 \: - \: Q_ {อันตราย}) $$
ในกรณีนี้น้ำหนักจะได้รับการอัปเดตเมื่อ Qj โดยที่อินพุตสุทธิใกล้เคียงกับ 0 เนื่องจาก t = 1.
Case 2 - ถ้า y ≠ t และ t = -1 จากนั้น
$$ w_ {ik} (ใหม่) \: = \: w_ {ik} (เก่า) \: + \: \ alpha (-1 \: - \: Q_ {ink}) x_ {i} $$
$$ b_ {k} (ใหม่) \: = \: b_ {k} (เก่า) \: + \: \ alpha (-1 \: - \: Q_ {ink}) $$
ในกรณีนี้น้ำหนักจะได้รับการอัปเดตเมื่อ Qk โดยที่อินพุตสุทธิเป็นบวกเพราะ t = -1.
ที่นี่ ‘y’ คือผลลัพธ์จริงและ ‘t’ คือผลลัพธ์ที่ต้องการ / เป้าหมาย
Case 3 - ถ้า y = t แล้ว
น้ำหนักจะไม่มีการเปลี่ยนแปลง
Step 8 - ทดสอบสภาพการหยุดซึ่งจะเกิดขึ้นเมื่อไม่มีการเปลี่ยนแปลงของน้ำหนักหรือการเปลี่ยนแปลงของน้ำหนักสูงสุดที่เกิดขึ้นระหว่างการฝึกซ้อมมีค่าน้อยกว่าค่าเผื่อที่กำหนด
ย้อนกลับเครือข่ายประสาทการแพร่กระจาย
Back Propagation Neural (BPN) คือโครงข่ายประสาทเทียมหลายชั้นซึ่งประกอบด้วยชั้นอินพุตชั้นที่ซ่อนอยู่และเลเยอร์เอาต์พุตอย่างน้อยหนึ่งชั้น ตามชื่อของมันการเผยแพร่ย้อนกลับจะเกิดขึ้นในเครือข่ายนี้ ข้อผิดพลาดซึ่งคำนวณที่เลเยอร์เอาต์พุตโดยการเปรียบเทียบเอาต์พุตเป้าหมายและเอาต์พุตจริงจะถูกส่งกลับไปยังเลเยอร์อินพุต
สถาปัตยกรรม
ดังที่แสดงในแผนภาพสถาปัตยกรรมของ BPN มีสามชั้นที่เชื่อมต่อกันซึ่งมีน้ำหนักอยู่ เลเยอร์ที่ซ่อนอยู่และเลเยอร์เอาต์พุตยังมีอคติซึ่งมีน้ำหนักเท่ากับ 1 เสมอ ดังที่เห็นได้ชัดจากแผนภาพการทำงานของ BPN มีสองขั้นตอน เฟสหนึ่งส่งสัญญาณจากชั้นอินพุตไปยังชั้นเอาต์พุตและอีกเฟสกลับเผยแพร่ข้อผิดพลาดจากชั้นเอาต์พุตไปยังชั้นอินพุต
อัลกอริทึมการฝึกอบรม
สำหรับการฝึกอบรม BPN จะใช้ฟังก์ชันการเปิดใช้งานไบนารีซิกมอยด์ การฝึกอบรมของ BPN จะมีสามขั้นตอนดังต่อไปนี้
Phase 1 - ฟีดไปข้างหน้าเฟส
Phase 2 - กลับเผยแพร่ข้อผิดพลาด
Phase 3 - อัปเดตน้ำหนัก
ขั้นตอนทั้งหมดนี้จะสรุปได้ในอัลกอริทึมดังนี้
Step 1 - เริ่มต้นสิ่งต่อไปนี้เพื่อเริ่มการฝึกอบรม -
- Weights
- อัตราการเรียนรู้ $ \ alpha $
สำหรับการคำนวณที่ง่ายและเรียบง่ายให้ใช้ค่าสุ่มเล็ก ๆ
Step 2 - ทำต่อขั้นตอนที่ 3-11 เมื่อเงื่อนไขการหยุดไม่เป็นจริง
Step 3 - ทำขั้นตอนที่ 4-10 ต่อทุกคู่การฝึก
ขั้นตอนที่ 1
Step 4 - หน่วยอินพุตแต่ละหน่วยรับสัญญาณอินพุต xi และส่งไปยังหน่วยที่ซ่อนอยู่สำหรับทุกคน i = 1 to n
Step 5 - คำนวณอินพุตสุทธิที่หน่วยที่ซ่อนอยู่โดยใช้ความสัมพันธ์ต่อไปนี้ -
$$ Q_ {อันตราย} \: = \: b_ {0j} \: + \: \ sum_ {i = 1} ^ n x_ {i} v_ {ij} \: \: \: \: j \: = \ : 1 \: ถึง \: p $$
ที่นี่ b0j คืออคติของหน่วยที่ซ่อนอยู่ vij น้ำหนักอยู่ที่ j หน่วยของเลเยอร์ที่ซ่อนอยู่มาจาก i หน่วยของชั้นอินพุต
ตอนนี้คำนวณผลลัพธ์สุทธิโดยใช้ฟังก์ชันการเปิดใช้งานต่อไปนี้
$$ Q_ {j} \: = \: f (Q_ {อันตราย}) $$
ส่งสัญญาณเอาต์พุตเหล่านี้ของยูนิตเลเยอร์ที่ซ่อนอยู่ไปยังยูนิตเลเยอร์เอาต์พุต
Step 6 - คำนวณอินพุตสุทธิที่หน่วยชั้นเอาต์พุตโดยใช้ความสัมพันธ์ต่อไปนี้ -
$$ y_ {ink} \: = \: b_ {0k} \: + \: \ sum_ {j = 1} ^ p \: Q_ {j} \: w_ {jk} \: \: k \: = \ : 1 \: ถึง \: m $$
ที่นี่ b0k เป็นอคติของหน่วยเอาท์พุท wjk น้ำหนักอยู่ที่ k หน่วยของชั้นเอาต์พุตที่มาจาก j หน่วยของชั้นที่ซ่อนอยู่
คำนวณผลลัพธ์สุทธิโดยใช้ฟังก์ชันการเปิดใช้งานต่อไปนี้
$$ y_ {k} \: = \: f (y_ {ink}) $$
ระยะที่ 2
Step 7 - คำนวณระยะการแก้ไขข้อผิดพลาดให้สอดคล้องกับรูปแบบเป้าหมายที่ได้รับในแต่ละหน่วยเอาต์พุตดังนี้ -
$$ \ delta_ {k} \: = \ :( t_ {k} \: - \: y_ {k}) f ^ {'} (y_ {ink}) $$
บนพื้นฐานนี้ให้อัปเดตน้ำหนักและอคติดังนี้ -
$$ \ Delta v_ {jk} \: = \: \ alpha \ delta_ {k} \: Q_ {ij} $$
$$ \ Delta b_ {0k} \: = \: \ alpha \ delta_ {k} $$
จากนั้นส่ง $ \ delta_ {k} $ กลับไปที่เลเยอร์ที่ซ่อนอยู่
Step 8 - ตอนนี้แต่ละหน่วยที่ซ่อนอยู่จะเป็นผลรวมของอินพุตเดลต้าจากหน่วยเอาต์พุต
$$ \ delta_ {อันตราย} \: = \: \ displaystyle \ sum \ LIMIT_ {k = 1} ^ m \ delta_ {k} \: w_ {jk} $$
สามารถคำนวณระยะผิดพลาดได้ดังนี้ -
$$ \ delta_ {j} \: = \: \ delta_ {อันตราย} f ^ {'} (Q_ {อันตราย}) $$
บนพื้นฐานนี้ให้อัปเดตน้ำหนักและอคติดังนี้ -
$$ \ Delta w_ {ij} \: = \: \ alpha \ delta_ {j} x_ {i} $$
$$ \ Delta b_ {0j} \: = \: \ alpha \ delta_ {j} $$
ระยะที่ 3
Step 9 - แต่ละหน่วยเอาต์พุต (ykk = 1 to m) ปรับปรุงน้ำหนักและอคติดังนี้ -
$$ v_ {jk} (ใหม่) \: = \: v_ {jk} (เก่า) \: + \: \ Delta v_ {jk} $$
$$ b_ {0k} (ใหม่) \: = \: b_ {0k} (เก่า) \: + \: \ Delta b_ {0k} $$
Step 10 - แต่ละหน่วยเอาต์พุต (zjj = 1 to p) ปรับปรุงน้ำหนักและอคติดังนี้ -
$$ w_ {ij} (ใหม่) \: = \: w_ {ij} (เก่า) \: + \: \ Delta w_ {ij} $$
$$ b_ {0j} (ใหม่) \: = \: b_ {0j} (เก่า) \: + \: \ Delta b_ {0j} $$
Step 11 - ตรวจสอบเงื่อนไขการหยุดซึ่งอาจเป็นได้ทั้งจำนวนยุคที่ถึงหรือผลลัพธ์เป้าหมายตรงกับผลลัพธ์จริง
กฎการเรียนรู้ทั่วไปของ Delta
กฎเดลต้าใช้งานได้กับเลเยอร์เอาต์พุตเท่านั้น ในทางกลับกันกฎเดลต้าทั่วไปเรียกอีกอย่างว่าback-propagation กฎคือวิธีการสร้างค่าที่ต้องการของเลเยอร์ที่ซ่อนอยู่
การกำหนดทางคณิตศาสตร์
สำหรับฟังก์ชั่นการเปิดใช้งาน $ y_ {k} \: = \: f (y_ {ink}) $ การมาของอินพุตสุทธิบนเลเยอร์ที่ซ่อนอยู่และในชั้นเอาต์พุตสามารถกำหนดได้โดย
$$ y_ {ink} \: = \: \ displaystyle \ sum \ LIMIT_i \: z_ {i} w_ {jk} $$
และ $ \: \: y_ {อันตราย} \: = \: \ sum_i x_ {i} v_ {ij} $
ตอนนี้ข้อผิดพลาดที่ต้องย่อให้เล็กที่สุดคือ
$$ E \: = \: \ frac {1} {2} \ displaystyle \ sum \ LIMIT_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2 $$
โดยใช้กฎลูกโซ่เรามี
$$ \ frac {\ partial E} {\ partial w_ {jk}} \: = \: \ frac {\ partial} {\ partial w_ {jk}} (\ frac {1} {2} \ displaystyle \ sum \ Limit_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2) $$
$$ = \: \ frac {\ partial} {\ partial w_ {jk}} \ lgroup \ frac {1} {2} [t_ {k} \: - \: t (y_ {ink})] ^ 2 \ rgroup $$
$$ = \: - [t_ {k} \: - \: y_ {k}] \ frac {\ partial} {\ partial w_ {jk}} f (y_ {ink}) $$
$$ = \: - [t_ {k} \: - \: y_ {k}] f (y_ {ink}) \ frac {\ partial} {\ partial w_ {jk}} (y_ {ink}) $$
$$ = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) z_ {j} $$
ตอนนี้ให้เราพูดว่า $ \ delta_ {k} \: = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) $
น้ำหนักในการเชื่อมต่อกับหน่วยที่ซ่อนอยู่ zj ได้โดย -
$$ \ frac {\ partial E} {\ partial v_ {ij}} \: = \: - \ displaystyle \ sum \ LIMIT_ {k} \ delta_ {k} \ frac {\ partial} {\ partial v_ {ij} } \ :( y_ {ink}) $$
ใส่ค่า $ y_ {ink} $ เราจะได้สิ่งต่อไปนี้
$$ \ delta_ {j} \: = \: - \ displaystyle \ sum \ LIMIT_ {k} \ delta_ {k} w_ {jk} f ^ {'} (z_ {อันตราย}) $$
การอัปเดตน้ำหนักสามารถทำได้ดังนี้ -
สำหรับหน่วยเอาต์พุต -
$$ \ Delta w_ {jk} \: = \: - \ alpha \ frac {\ partial E} {\ partial w_ {jk}} $$
$$ = \: \ alpha \: \ delta_ {k} \: z_ {j} $$
สำหรับยูนิตที่ซ่อนอยู่ -
$$ \ Delta v_ {ij} \: = \: - \ alpha \ frac {\ partial E} {\ partial v_ {ij}} $$
$$ = \: \ alpha \: \ delta_ {j} \: x_ {i} $$