Neural Network Algorithm

โดย ชิตพงษ์ กิตตินราดร | มกราคม 2563

Artificial neural network เป็น Algorithm หลักของการเรียนรู้แบบ Deep learning ซึ่งเป็นแนวทางการเรียนรู้แบบหนึ่งของ Machine learning

หลายคนคงเคยได้ยินมาว่า Deep learning ในปัจจุบันนั้นมีความสามารถมาก เช่นสามารถพยากรณ์มะเร็งจากภาพ X-ray ได้แม่นยำกว่าแพทย์ สามารถแยกแยะหน้าคนว่าใครเป็นใคร สามารถอ่านป้ายจราจรจากภาพถ่าย แยกเสียงพูดออกจากเสียงดนตรี เล่นหมากล้อมชนะแชมป์โลก ไปจนถึงการสร้างภาพดาราที่ไม่มีตัวตนจริง จะเห็นว่าความสามารถเหล่านี้ล้วนมีจุดร่วมกันอยู่หนึ่งอย่าง นั่นคือข้อมูล Input ที่ป้อนเข้า Deep learning algorithm มักจะเป็นข้อมูลแบบที่ไม่มีโครงสร้าง หรือที่เรียกว่า Unstructured data เช่น ภาพ ข้อความ เสียง ในขณะที่ Machine learning algorithm ทั่วไปมักจะเหมาะสมกับข้อมูลแบบ Structured data ที่มีโครงสร้างเป็นตาราง

อะไรคือสิ่งที่ทำให้ Neural network สามารถเรียนรู้จากข้อมูลที่ไม่มีโครงสร้างได้ดีกว่าวิธีอื่นๆ คำตอบอยู่ที่โครงสร้างการเรียนรู้ (Learning architecture) ของ Neural network ต่างจากโครงสร้างการเรียนรู้ของ Machine learning algorithm แบบทั่วไป

เรามาลองทำความเข้าใจโครงสร้างของการเรียนรู้ทั้งสองแบบกันว่าต่างกันอย่างไร

ใน Machine learning algorithm ทั่วไป เช่น Linear regression และ logistic regression โครงสร้างการเรียนรู้เป็นดังนี้:

จะเห็นว่ามี 3 ส่วน คือ Input, Classifier, และ Prediction

1) Input คือข้อมูลที่ป้อนเข้า Algorithm เช่นในกรณีนี้มี 3 Feature ได้แก่ $x_1$, $x_2$, และ $x_3$

2) Classifier คือฟังก์ชันที่นำเอา Input $x$ มาคำนวนร่วมกับค่าน้ำหนัก $w$ ของ $x$ แต่ละตัว ผลที่ได้เรียกว่า $z$ แล้วป้อน $z$ เข้าสู่ฟังก์ชันตัดสินใจ $\sigma$ เช่น Sigmoid function เพื่อคำนวนความเป็นไปได้ของคำตอบ

3) Prediction คือการตีความคำตอบของ Classifier แล้วนำเสนอผลลัพธ์ให้ผู้ใช้ เช่นคำถาม Binary classification ก็ให้คำตอบว่า "ใช่" หรือ "ไม่ใช่"

ในขณะที่ Neural network มีโครงสร้างการเรียนรู้ดังนี้:

จะเห็นว่ามี 4 ส่วน คือ Input layer, Hidden layer, Output layer, และ Prediction โดยเราจะอธิบายการทำงานทีละส่วน อนึ่ง เราเรียกกระบวนการที่ทั้ง 4 ส่วนนี้ทำงานต่อเนื่องกันจากด้านซ้ายไปด้านขวาของโครงสร้าง Neural network ว่ากระบวนการแผ่กระจายเดินหน้า หรือ Forward propagation ซึ่งทำงานร่วมกับการแผ่กระจายย้อนกลับ หรือ Backward propagation ซึ่งจะอธิบายภายหลัง

แต่ก่อนที่จะรู้จัก Forward propagation หลายคนอาจจะเคยได้ยินหรือเคยตั้งคำถามว่า Artificial neural network นี้มีความเหมือนหรือต่างกับการทำงานของสมองหรือไม่อย่างไร เราลองมาดูภาพ Neuron ในสมอง ซึ่งเป็นหน่วยที่รับ ประมวลผล และส่งข้อมูลไปยังส่วนอื่นๆ:

ภาพจาก BruceBlaus - Own work, CC BY 3.0

หากจะเปรียบเทียบ โครงสร้างที่เห็นคือ Neuron ซึ่งรับข้อมูลมาจาก Dendrite แล้วส่งข้อมูลออกไปยัง Neuron ตัวถัดไปผ่าน Axon โดย Neuron แต่ละตัวจะรับและส่งข้อมูลกับ Neuron อื่นๆ หลายตัว ปัจจุบันเรายังไม่มีความเข้าใจดีนักว่าโครงสร้างนี้มีความหมายต่อกระบวนการเรียนรู้ของมนุษย์อย่างไร แต่ถ้าจะให้คาดเดา ก็ดูเหมือนว่าโครงสร้างที่มีการเชื่อมโยงกันเป็นเครือข่ายแบบนี้น่าจะทำให้สมองมีความสามารถในการประมวลผลข้อมูลที่รับมา กลายเป็นการตัดสินใจทั้งระดับร่างกายและจิตใจได้ Artificial neural network ได้รับแรงบันดาลใจมาจากโครงสร้างนี้ ถึงแม้กลไกการทำงานไม่จำเป็นต้องเหมือนกันก็ตาม

Forward propagation

สมมุติว่า Algorithm มี Parameter $w$ และ $b$ ที่เป็นตัวแทนของข้อมูลเรียบร้อยแล้ว กระบวนการ Forward propagation คือการนำข้อมูล $x$ เข้ามาประมวลผลร่วมกับ Parameter เหล่านั้นเป็นชั้นๆ จนได้คำตอบ

อย่างไรก็ตาม ในตอนเริ่มต้น โมเดลจะยังไม่มี Parameter ที่ถูกต้อง เราจึงต้องสุ่มค่าเริ่มต้นของ Parameter ขึ้นมาก่อน เมื่อ Forward propagation ทำงานจบ 1 เที่ยว ก็จะเปรียบเทียบผลการพยากรณ์กับคำตอบที่รู้อยู่แล้ว จากนั้นโมเดลจะใช้กระบวนการตรงกันข้าม คือ Backward propagation ในการปรับค่า Parameter ให้สะท้อนข้อมูลใน Train set มากขึ้น ทำอย่างนี้หลายๆ รอบจนกระทั่งได้ความแม่นยำของโมเดลตามที่ต้องการ อนึ่งเราเรียกการทำงานไป-กลับแต่ละรอบว่า 1 Epoch (ภาษาไทยอาจแปล Epoch ว่า "กัป" ซึ่งฟังดูยิ่งใหญ่ดี แต่อาจจะไม่เหมาะกับบริบทนี้ จึงขอใช้ Epoch คำเดิม)

Forward propagation มีกระบวนการดังนี้:

1) Input layer คือข้อมูลขาเข้า ถ้าเป็นข้อมูลแบบมีโครงสร้าง $x$ แต่ละตัวจะแทน Feature หรือคอลัมน์ของข้อมูล เช่น อายุ เพศ รายได้ เป็นต้น

แต่ถ้าเป็นข้อมูลแบบไม่มีโครงสร้าง เช่นรูปภาพ $x$ แต่ละตัวจะแทนค่าความสว่างของภาพ 1 Pixel ดังนั้น ถ้าเรามีภาพขาวดำขนาด 64 คูณ 64 Pixel เราจะได้จำนวน Input $m = 64 \times 64 = 4096$ แต่ถ้าเป็นภาพสี ต้องคูณ 3 เข้าไป เพราะภาพสีแต่ละ Pixel จะมีข้อมูลความสว่าง 3 สี คือ Red, Green, Blue

2) Hidden layer คือชั้นประมวลผลที่ซ่อนอยู่ ซึ่งมีได้หลายชั้น (จากตัวอย่างแสดงชั้นเดียว) ใน Hidden layer แต่ละชั้นจะมีหน่วยประมวลผลที่เรียกว่า Neuron โดยในภาพมี 4 Neuron

หน้าที่ของ Neuron แต่ละตัว คือการรับข้อมูล Input "ทุกตัว" จาก Layer ก่อนหน้า มาประมวลผลโดยใช้ Linear function ร่วมกับค่าน้ำหนัก $w$ ของ Input แต่ละตัว ซึ่งให้ผล $z$ แล้วนำ $z$ ไปคำนวนใน Activation function $g$ ซึ่งอาจจะเป็น Sigmoid, Tanh, หรือ RELU ก็ได้ คำตอบที่ได้เรียกว่า $a$ สังเกตว่ากระบวนการนี้คล้ายกับขั้นตอน Classifier ของ ML algorithm ทั่วไป สิ่งที่ต่างคือชื่อเรียก สัญลักษณ์ที่ใช้แทน และจำนวน Neuron ที่มีมากกว่า 1

เราสามารถเขียนขั้นตอนนี้เป็นสมการได้ดังนี้:

สำหรับ $x^{(i)}$ แต่ละรายการ:

$$z^{[1](i)} = W^{[1]}x^{(i)} + b^{[1]} \tag{1}$$

$$a^{[1](i)} = g(z^{[1](i)}) \tag{2}$$

โดยก่อนจะไปไกลกว่านี้ มาทำความคุ้นเคยกับสัญลักษณ์แทนลำดับที่ของสิ่งต่างๆ ในโมเดลกันก่อน:

• $[1]$ ใน Brackets หมายถึงลำดับที่ของ Layer โดยนับ 1 ที่ Hidden layer แรก
• $(i)$ ใน Parentheses หมายถึงลำดับรายการข้อมูลที่ $i$
• $1$ ที่ห้อยด้านล่าง $a$ คือลำดับที่ของ Neuron ใน Layer นั้นๆ
• นำสัญลักษณ์ทั้งหมดมารวมกัน ตัวอย่างเช่น $a^{[1](4)}_3$ หมายถึง Activation function ตัวที่ 3 ของ Layer ที่ 1 ที่ทำงานกับข้อมูลรายการที่ 4

สิ่งสำคัญที่ต้องรู้ในขั้นนี้ คือ Hidden layer สามารถมีได้หลายชั้น เช่นถ้าหากมีชั้นที่ 2 สมการที่ (1) ก็จะนำ $a^{[1]}$ มาแทน $x$ และใช้ $W$ และ $b$ ของ Layer ที่สอง ดังนั้นเราสามารถเปลี่ยนรูปสมการที่ (1) และ (2) ให้เป็นรูปทั่วไปได้ดังนี้ (Vectorised form):

$$Z^{[l]} = W^{[l]}A^{[l-1]} + b^{[l]} \tag{3}$$

$$A^{[l]} = g(Z^{[l]}) \tag{4}$$

โดย $[l]$ คือลำดับที่ของ Layer ซึ่งนับ 1 ที่ Hidden layer ที่ 1

คำว่า Deep ใน Deep learning ก็มาจากการที่โมเดลมี Layer หลายชั้นในการประมวลผลนั่นเอง

3) Output layer คือชั้นที่ประมวลผล Activation $a$ ทั้งหมดจากชั้นก่อนหน้า โดยถือว่า $a^{[1]}$ คือ Input ร่วมกับค่าน้ำหนัก $W^{[2]}$ ของ $a^{[1]}$ ในชั้นก่อนหน้า (ไม่ใช่ของ $x$ ในชั้นแรก) ได้ผลเป็น $z^{[2]}$ แล้วนำ $z^{[2]}$ ไปคำนวนใน Activation function เช่น Sigmoid function ได้ผลเป็น $a^{[2]}$

เขียนเป็นสมการได้ดังนี้ (สังเกตว่าสอดคล้องกับสมการที่ (3) และ (4)):

$$z^{[2](i)} = W^{[2]}a^{[1](i)} + b^{[2]} \tag{5}$$

$$a^{[2](i)} = \sigma(z^{[2](i)}) \tag{6}$$

หรือเขียนเป็นรูปทั่วไป (Vectorised) คือ:

$$Z^{[L]} = W^{[L]}A^{[L-1]} + b^{[L]} \tag{7}$$

$$A^{[L]} = \sigma(Z^{[L]}) \tag{8}$$

โดย $[L]$ คือจำนวน Layer ทั้งหมด ดังนั้นจึงหมายถึง Layer สุดท้าย ส่วน $[L-1]$ ก็คือ Layer รองสุดท้าย

เพื่อความเข้าใจที่ดีขึ้น จะนำเสนอให้ดูว่าข้อมูลและตัวแปรแต่ละตัวใน Neural network มีหน้าตาอย่างไรในรูปแบบ Matrix และ Vector

สมมุติว่าเรามีข้อมูลดังนี้: Feature $n_0 = 4096$ จำนวน $m = 10000$ รายการ:

$$X = \begin{pmatrix} x_1^{(1)} & x_1^{(2)} & x_1^{(3)} & \cdots & x_1^{(10000)} \\ x_2^{(1)} & x_2^{(2)} & x_2^{(3)} & \cdots & x_2^{(10000)} \\ x_3^{(1)} & x_3^{(2)} & x_3^{(3)} & \cdots & x_3^{(10000)} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ x_{4096}^{(1)} & x_{4096}^{(2)} & x_{4096}^{(3)} & \cdots & x_{4096}^{(10000)} \\ \end{pmatrix} \tag{9}$$

มิติของ Matrix X คือ $(n_0, m) = (4096, 10000)$

เราจะใช้ข้อมูลชุดนี้ใน Neural network ขนาด Layer $L = 2$ โดยมีจำนวน Neuron ใน Layer แรก $n_1 = 4$ Neuron ส่วน Layer ที่สองเป็น Output layer ดังนั้นจึงมี $n_2 = 1$

ค่าน้ำหนัก $W^{[1]}$ จะต้องคูณแบบ Dot product กับ $X$ ได้ ดังนั้นจึงมีมิติ $(n_1, n_0) = (4, 4096)$:

$$W^{[1]} = \begin{pmatrix} w_1^{[1](1)} & w_1^{[1](2)} & w_1^{[1](3)} & \cdots & w_1^{[1](4096)} \\ w_2^{[1](1)} & w_2^{[1](2)} & w_2^{[1](3)} & \cdots & w_2^{[1](4096)} \\ w_3^{[1](1)} & w_3^{[1](2)} & w_3^{[1](3)} & \cdots & w_3^{[1](4096)} \\ w_4^{[1](1)} & w_4^{[1](2)} & w_4^{[1](3)} & \cdots & w_4^{[1](4096)} \\ \end{pmatrix} \tag{10}$$

เมื่อ $W^{[1]}X$ อยู่ในมิติ $(n_1, n_0) \times (n_0, m) = (n_1, m) = (4, 10000)$ ดังนั้น $b^{[1]}$ จึงจะต้องอยู่ในมิติ $(n_1, 1) = (4, 1)$ จึงจะสามารถบวกเข้าไปสมการได้:

$$b^{[1]} = \begin{pmatrix} b_1^{[1](1)} \\ b_2^{[1](1)} \\ b_3^{[1](1)} \\ b_4^{[1](1)} \\ \end{pmatrix} \tag{11}$$

เราต้องการ $Z^{[1]} = W^{[1]}X + b^{[1]}$ ดังนั้น $Z^{[1]}$ จึงต้องมีมิติ $(n_1, m) = (4, 10000)$:

$$Z^{[1]} = \begin{pmatrix} z_1^{[1](1)} & z_1^{[1](2)} & z_1^{[1](3)} & \cdots & z_1^{[1](10000)} \\ z_2^{[1](1)} & z_2^{[1](2)} & z_2^{[1](3)} & \cdots & z_2^{[1](10000)} \\ z_3^{[1](1)} & z_3^{[1](2)} & z_3^{[1](3)} & \cdots & z_3^{[1](10000)} \\ z_4^{[1](1)} & z_4^{[1](2)} & z_4^{[1](3)} & \cdots & z_4^{[1](10000)} \\ \end{pmatrix} \tag{12}$$

ส่วน $A^{[1]}$ ก็มีมิติ $(n_1, m)$ เหมือน $Z^{[1]}$ เพราะเป็นการนำ $Z^{[1]}$ มา Apply activation function ด้วยการ Broadcast ฟังก์ชันเข้าไปใน Matrix:

$$A^{[1]} = \begin{pmatrix} g(z_1^{[1](1)}) & g(z_1^{[1](2)}) & g(z_1^{[1](3)}) & \cdots & g(z_1^{[1](10000)}) \\ g(z_2^{[1](1)}) & g(z_2^{[1](2)}) & g(z_2^{[1](3)}) & \cdots & g(z_2^{[1](10000)}) \\ g(z_3^{[1](1)}) & g(z_3^{[1](2)}) & g(z_3^{[1](3)}) & \cdots & g(z_3^{[1](10000)}) \\ g(z_4^{[1](1)}) & g(z_4^{[1](2)}) & g(z_4^{[1](3)}) & \cdots & g(z_4^{[1](10000)}) \\ \end{pmatrix} \tag{13}$$

4) Prediction นำเอาผล Activation $a^{[2]}$ ของ Output layer มาตัดสินใจใน Decision function เพื่อพยากรณ์ เขียนเป็นสมการได้ดังนี้:

$$\hat{y}^{(i)} = a^{[2](i)} \tag{14}$$

$$y^{(i)}_{predict} = \begin{cases} 1 \quad \text{if } a^{[2](i)} \geq 0.5 \\ 0 \quad \text{if } a^{[2](i)} < 0.5 \end{cases} \tag{15}$$

ย้อนกลับมายังคำถามตั้งต้น ว่าทำไม Neural network จึงทำงานได้ดีกับข้อมูลแบบที่ไม่มีโครงสร้าง ลองพิจารณาดังนี้:

• ข้อมูลที่ไม่มีโครงสร้าง เช่นภาพ ข้อความ เสียง จะถูกนำเสนอในโมเดล ในลักษณะที่เป็น Feature จำนวนมาก โดยแต่ละ Feature แทนค่าหน่วยของข้อมูลที่บ่งบอกลักษณะของข้อมูลชิ้นนั้น เช่นความสว่างของ Pixel แต่ละจุด การนำเสนอแบบนี้ทำให้มนุษย์ไม่สามารถบอกหรือเตรียมล่วงหน้าได้ว่า Feature ไหนมีความสำคัญมากน้อย เพราะมีจำนวนมากและมีความซับซ้อนเกินกว่าที่สมองมนุษย์จะประมวลผลได้ ไม่เหมือน Feature ของข้อมูลที่มีโครงสร้างที่อยู่ในรูปของคอลัมน์ในตาราง ที่เราสามารถเตรียมเพิ่ม ลด ปรับแต่ง Feature เพื่อให้มีความหมายต่อโมเดล
• เมื่อเป็นเช่นนี้ หากเราใช้ Algorithm ทั่วไปในการเทรนข้อมูลที่มี Feature จำนวนมหาศาลแบบนี้ ก็มักจะได้ผลที่ไม่ดี เช่นเกิดปัญหา Variance ซึ่งก็คือการที่ Algorithm พยายามฟิตข้อมูลเข้ากับคำตอบที่รู้อยู่แล้ว แต่ Parameter เดียวกันนี้ไม่สามารถนำไปทำนายข้อมูลใหม่ที่มองไม่เห็นได้ดี เพราะจำนวนและความซับซ้อนของ Feature นั้นเกินกำลังที่ Algorithm ทั่วไปที่คำนวนชั้นเดียวจะสามารถทำความเข้าใจได้ดี
• ในขณะที่ Neural network จะแบ่งลำดับขั้นในการเรียนรู้ออกเป็นชั้นๆ โดยชั้นแรกจะเรียนรู้เพื่อแยกแยะ Feature อย่างหยาบๆ เช่น ถ้าเป็นภาพ ก็จะแยกบริเวณที่มีค่าความต่างของสีมาก เช่น ขอบของวัตถุ ออกมาก่อน จากนั้นจึงส่งข้อมูลที่แยกแยะเบื้องต้นแล้ว ไปยัง Layer ชั้นถัดไป ซึ่งจะได้รับข้อมูลที่ประมวลมาแล้ว นำไปแยกแยะค่าน้ำหนักของส่วนที่มีความละเอียดมากขึ้น เช่น ส่วนต่างๆ ของใบหน้า เป็นต้น
• การแยกแยะลักษณะของข้อมูลในแต่ละ Layer อาศัย Neuron หลายๆ ตัวทำงานพร้อมกัน โดยแต่ละตัวจะรับข้อมูลทั้งหมดจากชั้นที่แล้วเหมือนกัน แต่ให้ค่าน้ำหนัก $w$ ไม่เท่ากัน การที่ค่าน้ำหนักของข้อมูล $x$ แต่ละชิ้นไม่เท่ากันเลย ส่งผลเท่ากับการที่ Neuron แต่ละตัวช่วยกันประมวลข้อมูลเดียวกันโดยใช้มุมมองที่ต่างกันไปเล็กน้อย ทำให้เกิดผลเป็นการ Regularise ให้ข้อมูลลดโอกาสที่จะ Overfit train set ไปโดยปริยาย

ทบทวนอีกครั้งว่ากระบวนการทั้งหมดนี้ เรียกว่า Forward propagation ซึ่งจบลงด้วยการได้ค่าพยากรณ์ แต่แน่นอนว่าเมื่อเรายังไม่มี Parameter $w$ และ $b$ ที่ถูกต้อง ค่าที่พยากรณ์ได้ก็จะไม่ตรงกับความจริง ดังนั้นเราจะใช้กระบวนการ Backward propagation ในการปรับแต่ง Parameter ให้เป็นตัวแทนของข้อมูลได้เที่ยงตรงยิ่งขึ้น

Backward propagation

บางคนอาจจะเคยได้ยินว่า Backward propagation คือส่วนที่ซับซ้อนและยากที่สุดของ Neural network algorithm ซึ่งอาจจะจริงในส่วนของการคำนวน แต่โดยหลักคิดแล้วไม่ได้ยากขนาดนั้น เรามาลองทำความเข้าใจกันดู

ทบทวนว่า กระบวนการ Forward propagation จบลงที่เราได้ค่าพยากรณ์ ดังนั้นสิ่งต่อไปที่เราต้องทำ คือการนำค่าพยากรณ์นั้นมาใส่ใน Cost function เพื่อหาความต่างระหว่างค่าพยากรณ์กับค่าจริง โดยสำหรับ Neural network เราจะใช้ Cost function ลักษณะเดียวกันกับ Logistic regression คือ:

สมมุติว่า $L = 2$:

$$J = -\frac{1}{m} \sum\limits_{i=0}^{m} \left( y^{(i)} \log(a^{[2](i)}) + (1-y^{(i)}) \log(1-a^{[2](i)}) \right) \tag{16}$$

อนึ่ง หากใครสนใจ เราสามารถเขียนโค้ดของ Cost function โดยใช้ numpy ช่วย Vectorise เพื่อให้สามารถคำนวน Cost function ของรายการข้อมูลทั้งหมดได้อย่างรวดเร็วโดยไม่ต้องใช้ For loop โดยเขียนได้ดังนี้:

logprobs = np.multiply(np.log(A2),Y) + np.multiply(np.log(1-A2),1-Y)
cost = (-1/m)*np.sum(logprobs)

สิ่งต่อไปที่เราจะทำ คือเราจะหาว่า Parameter ที่ทำให้ Cost function มีค่าต่ำที่สุด โดยใช้กระบวนการ Gradient descent ซึ่งมีหลักการคือ:

1) หาอนุพันธ์ของ Parameter เช่น $w$ เมื่อเปรียบเทียบกับ Cost function $J$:

$$\frac{\partial J(w)}{\partial w}\tag{17}$$

2) นำอนุพันธ์ที่ได้ไปลบออกจาก Parameter นั้น โดยควบคุมความเร็วในการลบด้วย Learning rate $\alpha$ แล้วนำ Parameter ใหม่ไปคำนวนใน Forward propagation จะได้ Cost function ที่มีค่าลดลง ทำซ้ำขั้นตอนนี้ไปเรื่อยๆ จน Cost function มีค่าต่ำที่สุดที่จะเป็นไปได้:

ทำซ้ำจนกระทั่งผลลัพธ์ล่าสุดไม่เปลี่ยนแปลงจากผลลัพธ์ครั้งก่อน:

$$w := w - \alpha \frac{\partial}{\partial{w}} J(w)\tag{18}$$

กระบวนการดังกล่าวแสดงเป็นภาพได้ดังนี้:

ที่อธิบายไป เป็นภาพรวมของกระบวนการ แต่ใน Neural network เรามี Parameter หลายตัวและหลายชั้น ดังนั้นเราจึงต้องใช้หลายสมการในการหาอนุพันธ์ของ Parameter แต่ละตัว

โดย Parameter ที่ต้องหาอนุพันธ์ คือ Parameter ที่ส่งผลต่อค่าพยากรณ์ ได้แก่:

• $z$ ของแต่ละ Layer ไม่ได้เป็นตัวแปรที่ต้องการ Optimise แต่จำเป็นต้องหาอนุพันธ์เพื่อจะได้ใช้ Chain rule หาอนุพันธ์ของ $w$ และ $b$ ได้
• $w$ ของแต่ละ Layer เพราะเป็น Coefficient ของ $x$
• $b$ ของแต่ละ Layer เพราะเป็น Intercept ของ Linear function $z = wx + b$

จะไม่แสดงวิธีการหาอนุพันธ์ของ Parameter แต่ละตัว เพราะยุ่งยากซับซ้อนค่อนข้างมาก แต่จะแสดงให้เห็นเลยว่าอนุพันธ์ของแต่ละ Parameter คืออะไร:

สมมุติว่า $L = 2$:

$$\color{blue}{dz^{[2]}} = a^{[2]}-y \tag{19}$$

$$dW^{[2]} = \color{blue}{dz^{[2]}} a^{[1]T}\tag{20}$$

$$db^{[2]} = \color{blue}{dz^{[2]}} \tag{21}$$

$$\color{red}{dz^{[1]}} = W^{[2]T} \color{blue}{dz^{[2]}} \tag{22}$$

$$dW^{[1]} = \color{red}{dz^{[1]}} x^T \tag{23}$$

$$db^{[1]} = \color{red}{dz^{[1]}} \tag{24}$$

ทั้งนี้จะไม่แสดงวิธีคิดแบบ Vectorised เพราะอยากเน้นให้เข้าใจหลักการมากกว่า ส่วนในทางปฏิบัติให้ใช้ Framework อย่าง Tensorflow จะสะดวกกว่ามาก

สังเกตว่าเราหาอนุพันธ์ของ $z$ เช่น $\color{blue}{dz^{[2]}}$ และ $\color{red}{dz^{[1]}}$ เพื่อเป็นอนุพันธ์ตั้งต้นให้หาอนุพันธ์ของ $w$ และ $b$ ได้ตามที่เขียนไว้ข้างต้น

เมื่อเราได้อนุพันธ์ทั้ง 6 ตัว (สำหรับโมเดลความลึก 2 ชั้น ถ้า 3 ชั้นก็ต้องเพิ่มอีก 3 ตัว) เราก็จะเอาอนุพันธ์ของ $w$ และ $b$ ไปอัปเดตค่าตัวแปรทั้งสอง โดยทำดังนี้:

$$W^{[1]} := W^{[1]} - \alpha (dW^{[1]}) \tag{25}$$

$$b^{[1]} := b^{[1]} - \alpha (db^{[1]}) \tag{26}$$

$$W^{[2]} := W^{[2]} - \alpha (dW^{[2]}) \tag{27}$$

$$b^{[2]} := b^{[2]} - \alpha (db^{[2]}) \tag{28}$$

แล้วนำตัวแปรที่อัปเดตแล้วไปคำนวน Forward propagation ใน Epoch ใหม่ แล้วคิดอนุพันธ์ นำอนุพันธ์มาอัปเดตตัวแปร ทำอย่างนี้ซ้ำไปเรื่อยๆ จนถึงจุดที่ Cost function มีค่าต่ำที่สุด ก็จะได้โมเดลที่ฟิตกับ Train set ที่ดีที่สุดเท่าที่จะเป็นไปได้

มาถึงจุดนี้ ก็คงพอเข้าใจแล้วว่า Neural network ทำงานอย่างไร และเรียนรู้อย่างไร เรื่อง Neural network นี้มีรายละเอียดและวิธีการประยุกต์ใช้มากมาย ซึ่งจะค่อยๆ อธิบายในบทอื่นๆ

ส่วนในบทต่อไป เราจะเริ่มทดลองสร้างโมเดล Neural network และพยากรณ์ โดยใช้ Framework อย่าง Tensorflow และ Keras

หน้าแรก | บทที่ 13 Anomaly Detection | บทที่ 15 Neural Network Programming