สิ่ง สำคัญ ที่ ทำให้ Layer เคลื่อนที่ ได้ คือ

บทความนี้ผมเขียนเกี่ยวกับในส่วนของ Neuron และวิธีการเรียนรู้ของ Neural Network ซึ่งจะแบ่งเป็น 2 ส่วน: {Inside the Neuron, How do Neural Networks Learn?}

Inside The Neuron จะมี Weight, Bias,และ Activation Function

How do Neural Networks จะมี Cost Function, Gradient Descent, และ Backpropagation

ซึ่งจะต่อยอดจากบทความที่แล้ว

พื้นฐาน Deep Learning (ทฤษฎี): Intro

สำหรับผู้ที่สนใจที่จะเรียนรู้วิธีการสร้าง Deep Learning Model หรือ Artificial Neural Network, ใน Series…

medium.com

Recap (+ เพิ่มเติมนิดๆ, ข้ามก็ได้นะ)

การทำงานของ Neural Network, โดยเริ่มจาก Layers, ในส่วนของInput Layer จะมีจำนวน Neuron เท่ากับขนาดของ Data,

สมมติว่าเรามีภาพขนาด 28*28 pixels, จำนวนของ Neuronใน Input Layer ก็คือ 784 หรือ 28*28 Node

พอได้ข้อมูลมาแล้ว, แต่ละ Neuron ใน Input Layer ก็จะส่งตัวเลขของ Input ไปให้ Neuron อื่นๆ ใน Layer ต่อไป หรือใน ANN จะเรียกว่า Hidden Layer

โดยในแต่ละ Neuron ใน Hidden Layer จะมีสิ่งที่เรียกว่า Activation Function เพื่อ Transform ค่าทุกค่า ที่ได้รับมาจากทุกๆ Node ใน Layer ก่อนหน้า เพื่อ ส่งต่อไปยัง Layer ต่อไป,

แต่, ก่อนที่ทุกๆค่าจะเข้า Activation Function จะต้องมีการ ถ่วงน้ำหนักของค่าแต่ละค่าก่อน หรือ Weight, จะได้ในมารูป (xᵢ*wᵢ) หรือ (Input * Weight)

โดย Weight ตอนเริ่มต้นของ แต่ละ Input จะเป็นแบบสุ่ม, และค่อยๆเปลี่ยนแปลงไปเรื่อยๆ เพื่อให้ Fit กับ Data

พอถ่วงน้ำหนักเรียบร้อย, จะนำแต่ละค่าที่ถูกถ่วงน้ำหนักมารวมกัน(Sum) และเข้า Activation Function เพื่อ Transform ให้ออกมาเป็นค่า Output และส่งไปยัง Neuron ต่อไป

แต่ถ้าสังเกตจากภาพ จะมีสิ่งที่เรียกว่า Bias โผล่มาด้วย, Bias จะเป็นตัวแปรที่จะเลื่อน Activation Function ไปซ้ายหรือขวาครับ, อ่านแล้วอาจจะงง ผมอธิบายไว้ด้านล่างแล้วครับ

ถ้า่มองเป็นสูตรโดยรวม

output = activation_function( sum[inputs * weights]+ bias )

Recap ซะยาว และ งงนิดๆ แต่ไม่ต้องกังวลไปครับ เรื่องของ Parameters ผมอธิบายไว้ด้านล่างเรียบร้อย

Weight & Bias

สองตัวแปรนี้ เป็นตัวแปรที่จะเปลี่ยนแปลงค่าตัวเองไปเรื่อยๆระหว่างการ Train เพื่อให้ Fit กับ Data, เรียกว่า Learnable Parameters หรือ Trainable Parameters ซึ่งในทุกๆ Node ใน Neural Network จะมีตัวแปรสองตัวนี้เพื่อคอยปรับค่าของ Input, ซึ่งตอนเริ่มต้นของการ Train, Weight และ Bias จะสุ่มค่ามาก่อน

Weight

สมมติว่าคุณจะขายรถมือสอง, ราคาที่ลดลงจากมือหนึ่งอาจจะมีผลมาจาก สภาพ และ ระยะทาง(ใช้ขับไปแล้วกี่km)

แน่นอนว่า ทั้ง สภาพ และ ระยะทาง จะส่งผลกระทบต่อราคาด้วยขนาดที่ต่างกัน ซึ่งตัวที่บ่งบอกว่า ตัวไหนส่งผลน้อย หรือ มาก เราจะเรียกว่า น้ำหนัก(Weight)

หรือง่ายๆ,

น้ำหนัก เป็นตัวแปรที่บ่งบอกความสำคัญของค่าๆหนึ่ง

ซึ่งในมุมของ Deep Learning, Weight จะเป็นตัวที่ถ่วงน้ำหนักให้ Input ก่อนที่จะเข้าสู่ Node ก็หมายความว่า มันจะเป็นตัวบอกว่า Input ตัวนี้สำคัญแค่ไหน

output = activation_function( sum[inputs * weights]+ bias )

Bias

จะเป็นตัวแปรที่เข้าไป (+) หรือ (-) ค่าที่ได้หลังจากรวมรวมค่าทุกๆค่าก่อนจะเข้า Activation Function,

output = activation_function( sum[inputs * weights]+ bias )

ซึ่งมันจะส่งผลให้ตัว Activation Function เลื่อนไปซ้ายหรือขวา,

นั่นก็หมายความว่า, ค่า Output ที่ได้หลังจากผ่าน Activation Function จะเปลี่ยนแปลงไปตาม Bias ด้วย

ในภาพเคลื่อนไหว
x = sum(inputs * weights)
b = bias

สมมติว่า เราใช้ ReLU เป็น Activation Function แล้ว ค่า Weighted Sum ที่เราได้หลังจากรวม (Input*Weight)ทุกค่าแล้ว เท่ากับ (-0.35),

แน่นอนว่า ReLU(-0.35) = 0

นั่นก็หมายความว่า Node นี้จะไม่ทำงาน, ซึ่งมันอาจจะส่งผลดีหรือผลเสียต่อตัว Network หรือเปล่าก็ไม่ทราบ

แต่ที่เรามี Bias มา ก็เพื่อมาเปลี่ยนแปลงค่าของ Weighted Sum หรือ (-0.35) ที่เราได้มาจาก

sum(inputs*weights)

สมมติว่า Bias = 1 , จะได้ว่า ReLU(-0.35 + 1) = ReLU(0.65) = 0.65

ก็หมายความว่า Node นี้ที่มี Bias = 1 และ Weighted Sum = -0.35,

จะส่งค่า 0.65 ออกมา, หมายความว่า Node นี้จะทำงาน และส่งค่า 0.65 ไปให้ Node อื่นต่อๆไป

Activation Function

Activation Function, เป็นตัวบ่งบอกหน้าตาของ Neuron ว่า ถ้า Input ผ่านแต่ละ Neuron ใน Layer นี้ ค่าของ Output จะเป็นยังไง,
หรือนับว่าเป็นตัวแปลงค่า(Transform)ก็ได้

ซึ่งก่อนที่ Input ทุกๆตัวจะถูกส่งไปยัง Node อื่นๆ, จะต้องถูก Transform ให้ได้ค่าที่เหมาะสมก่อน และ ทุกๆ Node ต้องมี Activation Function

ถ้าสมมติว่า Neurons ใน Neural Network เราไม่มี Activation Function ล่ะ,

มันก็จะเป็นแค่ Linear Function ทั่วไป,

output = sum(inputs * weights) + bias
หรือ
y = mx + c

และแน่นอนว่า มันจะไม่ช่วยให้ Neural Network เรียนรู้อะไรที่ซับซ้อนของ Data เลย

ถ้ามองในมุมของ Classification,
Outputที่เราต้องการจะต้องออกมาในรูปความน่าจะเป็น ,
อย่างเช่น จะ Classify ผู้หญิงกับผู้ชาย, Output ที่ได้จากการ Classify จะได้ประมาณว่า ผู้ชาย: 0.18% , ผู้หญิง: 99.92%

ซึ่งแน่นอนว่า ถ้าใช้สมการ y = mx + c หรือสมการเส้นตรง มันทำไม่ได้อยู่แล้ว,
จะต้องใช้ฟังก์ชั่นอะไรซักอย่าง ที่ให้ผลลัพท์อยู่ในรูปแบบ Logit, ซึ่งก็ต้องใช้ Activation Funciton นั่นเอง

How do Neural Networks Learn?

หัวข้อนี้ผมนำAnimationส่วนใหญ่มาจากคลิปของ 3Blue1Brown นะครับ

3Blue1Brown

3blue1brown, by Grant Sanderson, is some combination of math and entertainment, depending on your disposition. The goal…

www.youtube.com

เพื่อให้เห็นภาพที่เข้าใจง่ายกว่า

สมมติว่าเรามี Neural Network
ที่ใช้ประมวลผลกับข้อมูลภาพขนาด 28*28 px (784px²) จาก MNIST Dataset

อ้างอิงจากภาพ, Node ที่ขึ้นสีขาวหมายถึง Node นั้นเกิดการทำงาน และส่งค่าไปให้ Node อื่นๆ, ซึ่งจะเห็นได้ว่า แต่ละ Node ในทุกๆ Hidden Layer ไม่ได้เกิดการทำงาน เพราะ ค่า Input หลังผสานกับ Weight และ Bias ไม่ผ่าน Activation Function ของ Node นั้น

ต้องเข้าใจก่อนว่า แต่ละ Node ใน Layer นั้นๆ จะจับ Pattern ของ Input นั้นๆ,
ซึ่งที่ทำอย่างนี้ได้ก็เพราะ
Neural Network พยายามที่จะเปลี่ยนค่าของ Weight และ Bias ของแต่ละ Node ให้เข้ากับ แต่ละ Pattern หรือ Feature ของ Data เรานั่นเอง (เพิ่มเติม: ถ้ามี Layer เยอะๆ และ Node เยอะๆ บางทีมันอาจจะจับ Pattern ที่ไม่จำเป็นและส่งผลเสียก็ได้)

ซึ่งการที่ตัว Neural Network จะทำแบบนี้ได้ จะต้องมาจากการเรียนรู้ข้อมูลครับ

สิ่งที่ Machine Learning Model มีคล้ายๆมนุษย์คือ Experience ครับ การเรียนรู้ข้อมูลก็ถือเป็น Experience และแน่นอนว่า,
บทเรียนดีๆ ได้มาจากความผิดพลาดครับ (นึกว่าเป็น Life Coach) ,

ด้วย

Cost Function เป็นฟังก์ชั่นที่ใช้ในการหาค่า Loss (แปลว่าการสูญเสีย) หรือ Cost, ซึ่งค่านี้จะเยอะเมื่อ Neural Network ส่งออกค่าที่ผิดออกมา
และจะน้อยเมื่อ Neural Network ส่งออกค่าที่ถูก.

เหมือนกับว่า กว่าจะได้ Output แบบนี้มา ต้องสูญเสียไปเท่าไร?
(ซึ่งยิ่งสูญเสียน้อยก็ยิ่งดีกว่า, ถูกหรือเปล่า?)

Cost Function ก็มีหลายแบบเหมือน Activation Function แหละครับ,

ลองดูภาพนี้ครับ

ในภาพนี้ คือเมื่อตอนที่ Neural Network กำลัง Train กับรูปเลข 3,
ลองสังเกตที่ทางขวาของภาพ

นี่คือ Output Layer ของ Neural Network ที่กล่าวถึงไว้ด้านบน

ทางซ้าย(กรอบสีเหลือง) คือ Output Layer ตอนที่ส่งออกค่า หลังจากได้รับรูปเลข 3 ไป,
สังเกตได้ว่า หลายๆ Node ส่งออก Output พร้อมๆกัน, ซึ่งบ่งบอกถึงความไม่มั่นใจของตัว Network เลย

ทางขวาคือ Output Layer ที่ควรจะเป็น, สังเกตได้ว่า มีเฉพาะ Node ของเลข 3 ที่ทำงาน,

ในขั้นนี้จะอยู่ในช่วงคำนวณครับ
(มองจากขวาไปซ้าย)
ลองสังเกตใน วงเล็บกำลัง2

ค่าที่ถูกส่งออกมา จะถูก ลบ ด้วย ค่าที่ควรถูกส่งออกมา
(ลองนำไปเปรียบเทียบกับภาพด้านบนครับ)

นั่นก็หมายถึง ถ้า Output ถูก ค่าก็จะน้อย, Output ผิด ค่าก็จะเยอะ

เสร็จแล้วก็นำ (y- ŷ)² ของทุก Node มารวมกัน

ซึ่งหลังจากผ่านขั้นตอนนี้ไปแล้ว ก็จะได้ Cost ของรูปๆนั้นมาครับ,

และแน่นอนว่า ถ้าหาก Output ออกมาถูกต้องตามความต้องการ ค่า Cost ก็จะน้อย

ตาม Loss Function (MSE)

จะต้องนำค่า (y- ŷ)²
ทั้งหมดมาหาค่าเฉลี่ย, จึงจะได้ ค่า Cost การ Train นั้นครับ

มาถึงตอนนี้, ต้องเข้าใจก่อนครับว่า Loss Function จะใช้กับค่า Output ของแต่ละ Node ใน Output Layer, จึงจะสามารถนำไปคำนวณค่า Weight ที่ควรจะเป็นได้ ด้วย

Gradient Descent เป็นวิธีการในการคำนวณหา จุดที่ต่ำที่สุด ของ Function นั้นๆ ด้วยการ Derivative (การหาความชัน) ของทีละจุดแล้วค่อยเลื่อนไปในจุดที่ต่ำกว่า ไปจนถึงจุดที่ต่ำที่สุด ที่เป็นไปได้,

จุดที่ต่ำที่สุดจะมี 2 แบบครับ: Global Minimum(จุดที่ต่ำที่สุดจริงๆ) และ Local Minimum(จุดที่ต่ำที่สุด ในระแวกนั้นๆ),

การที่จะหา Global Minimum มันยากกว่าการหา Local Minimum อยู่แล้ว เพราะบางที Gradient Descent Algorithm อาจมองLocal Minimumเป็นจุดที่ต่ำที่สุดจริงๆ
, เรียกเหตุการณ์นี้ว่า Local Trap ครับ ซึ่งจะแก้ได้ด้วย Momentum(ไม่มีในบทความ)

xₙ₊₁ = xₙ -α∇ f(xₙ)

(ถ้าเจอ Mojibake หรือตัวอักษรเพี้ยน,
กรุณาเข้าจาก Browser อื่น หรือ อ่านทาง Smartphone)

xₙ: ตำแหน่งของ Function ณ จุด ( n )

α: Learning Rate หรือ Step Size ใช้บอกขนาดของก้าว(สำคัญ)

∇ f(xₙ): Gradient ของ Fucntion นั้นๆ ณ จุด ( n )

“Gradient” หมายถึงทิศทางที่จะมีความชันสูงขึ้น
(คนถนัด Multivariable Calculus คงจะรู้ดี)

ถ้ามองเป็นเวกเตอร์ , ∇ f(xₙ) จะชี้ไปในทางที่มีความชันสูงกว่า
จึงต้องกลับด้านด้วยการ ลบ (-) เพื่อให้ชี้ไปทางที่มีความชันต่ำกว่า

ถ้าลองใช้ Gradient Descent Algorithm กับ ฟังก์ชั่นตัวแปรเดียว ( 1 Parameter)

f(x) = x⁴-3x³+2 ซึ่งค่า Global Minimum อยู่ที่ 2.25 (ตามทฤษฎีของ Fermat)

หากลองใช้
Learning Rate = 0.01
X₀ = 2 (เริ่มที่ 2)

จะพบ Local Minimum ที่ ~2.21 ซึ่ง ต่างจาก 2.25 อยู่ ~1.68%
และมีการเปลี่ยนแปลง 10 ครั้ง

แต่ถ้าหากลองใช้
Learning Rate = 0.001
X₀ = 2 (เริ่มที่ 2)

จะพบ Local Minimumที่ ~2.251 ซึ่งต่างจากค 2.25 อยู่ ~0.04%
และมีการเปลี่ยนแปลง 16 ครั้ง

ถ้าเราลองเปรียบเทียบ Learning Rate กับการ เดินทาง,

แน่นอนว่า ถ้าเราเดินแล้วแวะหลายๆที่ (Learning Rate ต่ำ)
มันจะใช้เวลาเยอะ แต่ก็อาจจะเจอ สิ่งที่เราต้องการจากการเดินทาง ก็ได้

แต่ ถ้าเราเดินแล้วแวะไม่กี่ที่ (Learning Rate สูง)
มันจะใช้เวลาน้อย แต่ก็อาจจะเจอหรือไม่เจอ สิ่งที่เราต้องการจากการเดินทาง ก็ได้

ถ้าสังเกตจากรูปด้านบนทั้งสองรูป,

แกน Y จะเป็นผลลัพท์ของ f(x) / แกน X จะเป็นค่าของ ( x )

สิ่งที่เราต้องการจาก Gradient Descent คือ

การหาค่าของ แกน X ที่ทำให้

แกน Y อยู่จุดที่ต่ำที่สุดของ Function

ในมุมของ Deep Learning

การ Gradient Descent จะใช้กับ Cost Function เพื่อเปลี่ยนแปลง Weight และ Bias, นั่นก็หมายถึง

เพื่อหาค่าของ Weight และ Bias ที่ทำให้

ค่า Cost อยู่จุดที่ต่ำที่สุดของ Cost Function

แต่เป็น Weight และ Bias ของ ทุกๆ Layer ที่ส่งผลให้ค่าของ Input เปลี่ยนแปลง,

เพราะฉะนั้น จะไม่ใช่เพียงแค่ 1 Parameter (1D) แน่นอน,
แต่มันจะใช้กับ ทุกๆ Weight และ Bias ใน Neural Network
(Parameter โคครเยอะ : หลาย Dimesions)

และการที่จะเปลี่ยน Weight และ Bias ของทุกๆ Node, จะต้องใช้วิธีการ

คำว่า Propagate แปลว่า {เผยแพร่, ส่งต่อ, ถ่ายทอด},

ในมุมของ Deep Learning, จะมีขั้นตอน Forwardpass(Forward Propagation)
กับ Backwardpass (Backward Propagation)

ซึ่งขั้นตอน Forward Propagation ก็เป็นขั้นตอนที่ทำให้ Neural Network ส่งต่อ Input ไปข้างหน้า ทีละ Layer จนได้ Output ออกมา

Backward Propagation เป็นขั้นตอนที่จะใช้ร่วมกับ
Cost Function และ Gradient Descent เพื่อหา Error และนำ Errorไปหา Weight และ Bias ที่ทำให้ Error ลดลง, พอได้ Weight และ Bias ที่ทำให้ Error ลดลงแล้ว ก็จะค่อยๆเปลี่ยน Weight และ Bias ไปทีละ Layer.

ลองนึกถึงตอนที่ Neural Network เรากำลังโง่อยู่ แล้วให้ Output ตอนกำลัง Train กับรูปเลขสองแบบมั่วๆ

สิ่งที่เราต้องการคือ, เราต้องการให้ค่า Output ของ Node เลข 2 สูงขึ้น
และต้องการให้ค่า Output ของ Node อื่นๆ ต่ำลง

และขนาดของลูกศร ที่แสดงไว้ในภาพเคลื่อนไหว ก็หมายถึง เราต้องการเปลี่ยนแปลงค่า Output ของ Node นั้นๆ มากแค่ไหน, สูงขึ้นหรือต่ำลง

นั่นก็บ่งบอกถึง การที่จะ เพิ่มค่าของ Node เลข 2 สำคัญกว่า การลดค่าของ Node เลข 8 มากๆ ซึ่งมันก็ส่ง Output มาในค่าที่มันควรจะเป็นแล้ว,

ทีนี้ ลองมาสังเกตที่ Node ของ เลข 2 (Node ที่เราต้องการให้ค่า Output เพิ่ม)

Outputนี้(0.2) ได้มาจาก activation_function( sum[inputs * weights]+bias )
ของ Layer ก่อนหน้านี้

การที่เราจะเพิ่มค่า Output ของ Node นั้นได้ ก็ต้องมาจากการเพิ่ม Weight และ Bias

สังเกตที่ Node ของ Hidden Layer
ที่มีสีขาวมากสุด(Output เยอะ)

4 Nodeนั้น จะมีผลมากที่สุดในการเปลี่ยนแปลงค่าของ Node เลข 2

เพราะฉนั้นก็หมายความว่า หากเปลี่ยนแปลง Weight และ Bias ให้ 4 Node นี้ จะทำให้ Output ของเลข 2 เปลี่ยนแปลงไปอย่างมาก

ส่งผลใน Error เปลี่ยนแปลงไปอย่างมากเช่นกัน ซึ่งจะดีหรือไม่
ก็อยู่ที่ว่า Weight และ Biasจะเปลี่ยนไปในทิศทางไหน

เปรียบเสมือนกับคำว่า
“Neurons that fire together, wire together.” ของ Donald Hebb
ถ้าให้อธิบายง่ายๆ, ก็เหมือนกับว่า เมื่อ 4 Node นั้นเจอเลข 2(ในรูปของ Input)
จะมีผลอย่างมากกับ Node ของเลข 2 (เพราะนึกถึงเลข 2 อยู่แล้ว)

แต่ก็ไม่ใช่ว่าจะต้องเปลี่ยนแค่ 4 Node นั้น,

สำหรับ Node ที่มี Weight เป็น (-),
ก็จะ ถูกลดค่า Weight

และ Node ที่มี Weight เป็น (+),
ก็จะ ถูกเพิ่มค่า Weight

การที่ค่า Weight และ Bias
จะเปลี่ยนแปลงมากเท่าไร
ขึ้นอยู่กับว่า,
จะช่วยให้ค่า Error ลดลงมากแค่ไหน

นี่เป็นเพียงแค่ ความต้องการที่จะให้ค่า Output ของ Nodeเลข2 เพิ่มขึ้น

เรายังมีค่าของ Output Nodes อื่นๆที่ต้องการให้ลดลงเช่นกัน

ทำด้วยวิธีเดิม กับทุกๆ Node ไปเรื่อยๆจนจบ

แล้วก็นำค่าของการเปลี่ยนแปลงทุกๆค่า ของ Node นั้นๆมารวมกัน

และก็ทำวิธีเดิมซ้ำกับ Layer ก่อนหน้า ไปเรื่อยๆ จนถึง Input Layer

และจะได้ค่า Weight ทุกๆอันมา

และนั่น ก็เป็นเพียงสำหรับ รูปเลข 2 รูปเดียวเท่านั้น,
ใน Training Data ยังมีรูปอีกหลายรูป ซึ่งก็ใช้วิธีเดิมซ้ำๆไปเรื่อยๆ

แล้วก็นำค่าของ Weight และ Bias ของ Node นั้นๆ มาหาค่าเฉลี่ย และ Update ค่านั้น, ซึ่งนั่นก็คือค่าของแต่ละ Parameter ในวิธีการ Gradient Descent นั่นเอง

ซึ่งค่าเหล่านี่ จะเป็นค่าของ Weight และ Bias(ไม่มีในภาพ) ที่จะถูกเปลี่ยน.

มาถึงจุดนี้แล้ว ผมอยากให้รู้จักคำสำคัญๆ เช่น epoch และ batch ไว้หน่อย,

Epoch หมายถึง จำนวนครั้งในการที่จะให้ตัว Neural Network เรียนรู้ Data นั้นๆ ทั้งหมดตั้งแต่หัวจรดเท้า,
อย่างเช่น เรากำหนดให้ Neural Network เรียนรู้กับ Data นี้ 100 Epoch,เวลา Train,
Neural Network จะเรียนรู้ และ เปลี่ยนแปลงค่าให้ Fit กับ Data นี้ ซ้ำไป 100 ครั้ง (ในกรณีใช้วิธี Batch Gradient Descent และ ใช้เวลานานมากกกกก)

Batch หมายถึง ชุดของข้อมูล ที่ถูกแบ่งออกมาเป็นชุดๆ จากข้อมูลทั้งหมด ,
สมมติว่า Training Data เรามี 256 Input, ถ้าเราเลือก Batch Size = 32,
ก็หมายความว่า เราจะมี Batch 8 ชุด (32*8=256)

ที่ผมพูดถึง 2 คำนี้ ก็เพราะมันมีผลต่อการ Update Weight & Bias และการ Train

และแน่นอน ถ้าใช้วิธีการ Backpropagation กับ Batch Gradient Descent(วิธีที่ใช้ในรูปด้านบน) จะต้องใช้เวลานานมาก เพราะต้องคำนวณ Weight และ Bias ของทุกๆ หInput ที่มี
ซึ่งนั่นก็ทำให้

Gradient Descient แบ่งเป็น 3 ประเภท

Batch Gradient Descent
วิธีนี้ จะคอยหาค่า Weight และ Bias ที่จะเปลี่ยน, ทีละ 1 ข้อมูลตัวอย่าง(Training Example) และจะหาไปเรื่อยๆจนครบทั้งหมดใน Training Data จึงค่อยทำการหาค่าเฉลี่ย ละเปลี่ยนแปลงค่าทั้งหมด,
และจะคอยทำซ้ำๆไปเรื่อยตามจำนวน Epoch ที่เรากำหนด,
ซึ่งจะใช้เวลานานและกินพื้นที่
(อย่างที่กล่าวไว้ด้านบน)

Stochastic Gradient Descent
วิธีนี้จะเปลี่ยนค่า Parameters(Weight & Bias) ทุกๆครั้ง หลังจากผ่านไป 1 ข้อมูลตัวอย่าง, วิธีนี้จะเร็วกว่า Batch Gradient Descent ก็ขึ้นอยู่กับปัญหา
ข้อดีของมันคือ จะ Update ค่า Parameters แบบละเอียด แต่ก็มากับ
ข้อเสียที่ว่า อาจเกิด noisy gradients, และอาจเพิ่มค่า Error อย่างสูงแทนที่จะลด

Mini Batch Gradient Descent
วิธีนี้เป็นวิธีทีใช้กันอย่างแพร่หลาย, เริ่มจากการ สับเปลี่ยน Training Data และ แบ่งออกเป็นชุดๆ เรียกว่า Batch หรือ Mini-Batch, โดยจะ คำนวณและ Update Parameters ทุกครั้ง หลังจาก ผ่านไป ทีละ Batch, ก็เหมือนกับแบบอื่นๆที่มีข้อดีและข้อเสีย แต่ทั้งหมดขึ้นอยู่กับปัญหาทั้งนั้น

ถ้าลองรวบรวมทุกอย่าง แล้วอธิบาย

เริ่มจาก, Neural Network เราจะแบ่งเป็น Layer 3 ชนิด แบ่งเป็น Input, Output, และ Hidden Layer
โดยที่ Input Layer จะเป็น layer ที่มีจำนวน Neuron(Node) เท่ากับขนาดของข้อมูล,
Output Layer จะใช้เพื่อ การส่งออกผลลัพท์ของ Neural Network เรา และจะมีจำนวน Node เท่ากับจำนวน Class,
Hidden Layer เป็นส่วนที่ใช้เพื่อหา Feature จากข้อมูล โดยในแต่ละ Node ในแต่ละ Layer จะหา Pattern ใน Data นั้นๆ ด้วยการเปลี่ยนแปลง Weight และ Bias ให้ Fit กับ Data,

Activation Function จะเป็นหน้าตาของ Node, Output layer จะใช้ Softmax ถ้าใช้เพื่อการ Classification,
Weight และ Bias เป็น Parameter ที่จะเพิ่มหรือลดค่าให้ ทุกๆ Input เพื่อให้ผ่านหรือไม่ผ่าน Activation Function, Weight เป็นตัวบ่งบอกความสำคัญ, Bias เลื่อน Activation Function

Neural Network จะแบ่งเป็น 2 ขั้นตอน Forward และ Backward

การทำให้ Neural Network Fit กับ Data หรือ การเรียนรู้ของ Neural Network,
จะใช้วิธี Backward Propagation ซึ่งเป็นการส่งค่า Error ย้อนกลับไป
ให้ทุกๆ Node Update Parameters เพื่อให้ Fit กับ Data ด้วยการลด Error

ค่า Error หรือ Cost หรือ Loss หาด้วย Cost(Error, Loss) Function ซึ่งเป็นค่าที่บ่งบอกถึงความผิดพลาดที่ได้จากการ Train

การหาค่า Parameters ที่จะทำให้ Error ลดลงได้ จะต้องใช้วิธี Gradient Descent เพื่อหา ค่า Weight และ Bias ที่ทำให้อยู่จุดที่มีค่า Error ต่ำที่สุดเท่าที่เป็นไปได้

Backward Propagation ใช้วิธีการ Gradient Descent เพื่อหาค่า Parameters ที่ทำให้ ค่า Error ลดและจำนำไป Update กับทุกๆ Parameters

เท่านี้ก็ถือว่าเรียบร้อย

เพิ่มเติม

หลายๆการกระทำในบทความนี้ใช้ Calculus(โดยเฉพาะ Backpropagation) ถ้าสนใจศึกษาเพิ่มเติม ผมแนะนำให้ไปลองดูคลิปของคุณ 3Blue1Brown ครับ

สำหรับผู้ที่อ่านจบ, ขอบคุณนะครับที่ทนอ่านบทความนี้มา, หากมีจุดไหนผิดพลาด หรืออยากจะให้แก้ไข ก็ Feedback มาได้นะครับ