Lecture3.pdf (49 หน้า — เนื้อหาเดียวกับ Lecture2.pdf หน้า 50-98) · 2603520 Deep Learning

Cost Function & Backpropagation: สอนเครือข่ายให้เรียนรู้ด้วย Chain Rule

นี่คือหัวใจของข้อสอบวิชานี้ และเป็นบทที่ยาวที่สุด. เรื่องราวทั้งบทมีเส้นเดียว: เรามีเครือข่ายที่ทำนายผิด → ต้องมีตัวเลขบอกว่า "ผิดแค่ไหน" (cost function) → ต้องรู้ว่าจะขยับ weight แต่ละตัวไปทางไหน (อนุพันธ์ย่อย) → เครือข่ายลึกทำให้หาอนุพันธ์ตรงๆ ยาก (chain rule ยาว) → backpropagation คือวิธีคำนวณมันอย่างประหยัด. ทุกอย่างที่เหลือในบทนี้ (activation function, regularization, การแบ่งข้อมูล, hyperparameter) คือรายละเอียดที่ห้อยอยู่กับเส้นนี้.

สไลด์ของบทนี้ตั้งใจเว้น "คำตอบตัวเลข" ของตัวอย่างไว้ให้กรอกในคาบ — บทเรียนนี้จะคำนวณให้ครบทุกตัวเลขทุกหน้า (ตรวจด้วย numpy ทุกค่า) พร้อมพิสูจน์ที่มาของสูตร \(\delta\) ทีละขั้น และอธิบายคณิตศาสตร์พื้นฐานทุกตัวตั้งแต่ศูนย์.

0. Cost Function และ Parameter Learning: ปัญหาตั้งต้นของทั้งบท

ก่อนพูดถึง backpropagation เลยแม้แต่คำเดียว ต้องตอบคำถามที่ง่ายกว่านั้นมากก่อน: "เครือข่ายของเรารู้ได้อย่างไรว่ามันทำนายผิด?" ลองนึกภาพว่าคุณสอนเด็กทายราคาบ้าน เด็กทายว่า 2 ล้าน ราคาจริง 3 ล้าน. ถ้าคุณบอกแค่ "ผิด" เด็กไม่รู้ว่าต้องปรับมากแค่ไหน. แต่ถ้าคุณบอก "ผิดไป 1 ล้าน" เด็กรู้ทั้งขนาดและทิศทาง. Cost function คือเครื่องมือที่แปลง "ความผิด" ให้เป็นตัวเลขตัวเดียว ที่เอาไปคำนวณต่อได้.

อาจารย์เปิดบทด้วยประโยคเดียวที่ทำสีไว้: cost function คือฟังก์ชันที่ใช้measure the accuracy of the hypothesis function — วัดว่า hypothesis function (ฟังก์ชันทำนายของเรา \(h_\theta(x)\)) แม่นแค่ไหน. และแยกเป็นสองแบบตามชนิดของปัญหา: Regression Problem · Classification Problem (กรณีหลังในสไลด์คือแบบ 1 output node).

แบบที่ 1 — Regression (ทำนายตัวเลขต่อเนื่อง เช่น ราคาบ้าน):

เอาผลต่าง (ทำนาย − จริง) ของทุกตัวอย่างมายกกำลังสอง แล้วเฉลี่ย

ทำไมต้องยกกำลังสอง? เพราะ (1) กำจัดเครื่องหมาย — ทำนายเกิน 1 กับทำนายขาด 1 ผิดพอกัน ถ้าไม่ยกกำลังสองมันจะหักล้างกันจนดูเหมือนไม่ผิดเลย และ (2) ลงโทษความผิดใหญ่หนักกว่าความผิดเล็กแบบทวีคูณ (ผิด 2 หน่วยโดนปรับ 4 ส่วนผิด 1 หน่วยโดนปรับแค่ 1). ลองกับตัวเลขจริง บ้าน 3 หลัง ทำนาย \(h = [2, 4, 5]\) ล้าน ราคาจริง \(y = [3, 4, 7]\) ล้าน: ผลต่าง \([-1, 0, -2]\) ⇒ ยกกำลังสอง \([1, 0, 4]\) ⇒ ผลรวม 5 ⇒ \(J = 5/3 = 1.667\). สังเกตว่าบ้านหลังที่ 3 (ผิด 2 ล้าน) ออกแรงในค่า cost มากถึง 4 ใน 5 ส่วน — cost function ชนิดนี้จึงบีบให้โมเดลแก้ความผิดก้อนใหญ่ก่อน.

แบบที่ 2 — Classification (ทำนายคลาส 0/1, output 1 node) ใช้ cross-entropy:

ถ้าคำตอบจริงคือ 1 ให้ค่าปรับ \(-\log h\); ถ้าคำตอบจริงคือ 0 ให้ค่าปรับ \(-\log(1-h)\) — มีแค่เทอมเดียวทำงานเสมอ

กลไกของ "สวิตช์" นี้: ถ้า \(y=1\) ตัวคูณ \((1-y)=0\) ทำให้เทอมหลังหายไปทั้งก้อน เหลือ \(-\log h\); ถ้า \(y=0\) ตัวคูณ \(y=0\) ทำให้เทอมหน้าหายไป เหลือ \(-\log(1-h)\). ลองตัวเลข (กรณี \(y=1\)): ทำนาย \(h=0.9\) ⇒ ค่าปรับ \(-\ln 0.9 = 0.105\) (เกือบถูก ปรับน้อย); \(h=0.5\) ⇒ \(0.693\); \(h=0.1\) ⇒ \(2.303\) (มั่นใจผิดทาง ปรับหนักกว่า 20 เท่าของกรณีแรก). นี่คือเหตุผลที่ classification ไม่ใช้ MSE: cross-entropy ลงโทษ "มั่นใจแต่ผิด" อย่างรุนแรง ส่วน MSE จะปรับแค่ \((0.1-1)^2 = 0.81\) ซึ่งไม่ต่างจาก \((0.5-1)^2=0.25\) มากพอจะผลักโมเดลออกจากความมั่นใจผิดๆ.

บรรทัดสุดท้ายของหน้านี้คือคำถามที่เหลือทั้งบท: "How to choose a set of parameter → \(\theta_{ij}^{[l]}\) to fit a model" — จะเลือกค่า weight ทุกตัวอย่างไรให้ cost ต่ำที่สุด.

คำตอบคือ gradient descent สูตรเดียวกับ Lesson 1 แต่เขียนด้วย index ของเครือข่าย:

อ่านทีละสัญลักษณ์: \(l\) = เลเยอร์, \(i\) = node ปลายทางในเลเยอร์ \(l\), \(j\) = node ต้นทางในเลเยอร์ \(l-1\), \(\alpha\) = learning rate (ก้าวยาวแค่ไหน), \(:=\) = "กำหนดค่าใหม่ให้" (ไม่ใช่สมการเท่ากับ). สไลด์ยกตัวอย่างสองตัวแรกให้เห็นว่ามันทำกับ weight ทุกตัว: \(\theta_{1,0} := \theta_{1,0} - \alpha\frac{\partial J}{\partial\theta_{1,0}}\), \(\theta_{1,1} := \theta_{1,1} - \alpha\frac{\partial J}{\partial\theta_{1,1}}\), …

คำว่า "simultaneously update" ในสไลด์คือกับดักข้อสอบ: ต้องคำนวณอนุพันธ์ทุกตัวจาก \(\theta\) ชุดเดิมให้เสร็จก่อน แล้วค่อยเขียนทับพร้อมกัน. ถ้าอัปเดต \(\theta_{1,0}\) ก่อนแล้วเอาค่าใหม่ไปคำนวณอนุพันธ์ของ \(\theta_{1,1}\) นั่นไม่ใช่ gradient descent แล้ว (เป็นคนละอัลกอริทึม และอาจไม่ลู่เข้า).

ด้านขวาของหน้ามีคำเตือนที่ทำสีไว้: nonconvex – Local Optima Problems. ความหมาย: พื้นผิวของ cost function ของเครือข่ายประสาทเทียมไม่ใช่ชามใบเดียว (convex) แบบ linear/logistic regression แต่เป็นภูมิประเทศที่มีหุบเขาหลายลูก. gradient descent เดินลงเขาได้อย่างเดียว ถ้ามันตกลงไปในหุบเล็ก (local minimum) มันจะติดอยู่ตรงนั้นแม้จะมีหุบที่ลึกกว่า (global minimum) อยู่อีกฝั่ง. นี่คือเหตุผลที่ผลการเทรนขึ้นกับค่าเริ่มต้นที่สุ่มมา — เทรนสองครั้งด้วยข้อมูลเดียวกันอาจได้ weight คนละชุด.

แต่สไลด์ก็ใส่กรอบปลอบใจไว้ด้วย (อ้าง Hands-on Machine Learning with Scikit-Learn, Keras, and TensorFlow หน้า 279): "In practice, it turns out that this is rather rare in practice and usually fairly close to the global optimum." — ในทางปฏิบัติ local optima ที่แย่จริงๆ พบได้ยาก และจุดที่ติดมักให้ค่า cost ใกล้เคียงกับ global optimum อยู่แล้ว. ข้อสอบชอบถามตรงนี้: คำตอบที่ถูกคือ "nonconvex เป็นปัญหาในทางทฤษฎี แต่ในทางปฏิบัติมักไม่ร้ายแรง" ไม่ใช่ "nonconvex ทำให้เทรนไม่ได้" และไม่ใช่ "cost ของ NN เป็น convex".

ย่อหน้าสุดท้ายของหน้าคือประตูสู่ทั้งบท: "since neural networks can have many layers, computing the partial derivative of the cost at a specific node in an earlier layer with respect to parameters in the first layer is challenging. To address this problem, the backpropagation algorithm is used to efficiently compute these partial derivatives." — สูตร gradient descent ข้างบนสมมติว่าเรามี \(\partial J/\partial\theta\) อยู่แล้ว. ปัญหาจริงคือจะหามันอย่างไรเมื่อ \(\theta\) อยู่ลึกเข้าไปหลายชั้น. backpropagation คือคำตอบนั้น.

1. Chain Rule: เครื่องมือเดียวที่ใช้พิสูจน์ backprop ทั้งหมด

ปัญหาที่หน้า 2 ทิ้งไว้คือ "หา \(\partial J/\partial\theta\) ของ weight ที่อยู่ลึกได้อย่างไร". อุปสรรคคือ weight ตัวนั้นไม่ได้ปรากฏใน \(J\) โดยตรง — มันส่งผลผ่านตัวกลางหลายทอด. เครื่องมือคณิตศาสตร์ที่จัดการเรื่อง "ผลกระทบผ่านตัวกลาง" ได้ชื่อว่า chain rule และมันคือเครื่องมือตัวเดียวที่ใช้ทั้งบท.

สไลด์หน้า 3 นิยาม backpropagation ว่าเป็น algorithm ที่ใช้compute partial derivative (หรือที่เรียกว่าgradient) ของ output error ของเครือข่าย (หรือที่เรียกว่าcost) เทียบกับพารามิเตอร์แต่ละตัว (หรือที่เรียกว่าweight) เพื่อเอาไปเรียนรู้ weight ด้วยgradient descent นั่นคือค่า \(\dfrac{\partial J(\theta)}{\partial\theta_{ij}^{[l]}}\).

คำสี่คำนี้คือคำเดียวกันในภาษาต่างกัน และอาจารย์ตั้งใจทำสีเพื่อบอกว่าข้อสอบจะสลับคำพวกนี้: "partial derivative" = "gradient" (gradient คือเวกเตอร์ของอนุพันธ์ย่อยทุกตัว), "output error" = "cost", "parameter" = "weight". ประโยคสรุปที่มุมล่างของหน้าคือคำอธิบาย backprop ที่สั้นที่สุดในสไลด์ทั้งเล่ม: "Backpropagation → how much each weight connection contributed to the error" — backprop ตอบว่าเส้นเชื่อมแต่ละเส้นมีส่วนทำให้เกิดความผิดพลาดมากแค่ไหน.

สไลด์บอกต่อว่า backprop "built on the concept of the Chain Rule" — เทคนิคสำหรับ "differentiating a function of a function". รูปแบบ: ถ้า \(y = f(u)\) และ \(u = g(x)\) แล้วอนุพันธ์ของ \(f(g(x))\) คือ

เหมือนอัตราแลกเงิน: บาท→ดอลลาร์ ×0.03 แล้ว ดอลลาร์→ยูโร ×0.92 ⇒ บาท→ยูโร ×(0.03×0.92) — อัตราแต่ละทอด "คูณต่อกัน"

สไลด์ทิ้งโจทย์ฝึกมือไว้ 2 ข้อก่อนเข้า backprop จริง โดยไม่ได้เฉลย — เราจะแก้ให้ครบทั้งสองข้อ.

2. จาก Chain Rule สู่ \(\partial J/\partial\theta\): สูตรทั่วไปของ Backprop

ตอนนี้เรามีเครื่องมือ (chain rule) และมีเป้าหมาย (\(\partial J/\partial\theta\)) แล้ว. หัวข้อนี้คือการเอาเครื่องมือไปจ่อกับเครือข่ายจริง ทีละสูตร จนได้ "สูตรสำเร็จ" ที่ใช้กับเครือข่ายกี่ชั้นก็ได้.

ประโยคเปิดของหน้านี้คือกุญแจ: "Neural network is a composite function" — เครือข่ายคือฟังก์ชันซ้อนฟังก์ชันตามที่เราเพิ่งฝึกใน §1. เมื่อเป็นเช่นนั้น chain rule ก็ใช้ได้ทันที และสไลด์เขียนสองสมการเทียบกันให้เห็นว่า "ยิ่งลึกยิ่งยาว":

weight ของ layer สุดท้ายมี 2 ทอด; weight ของ layer แรกมี 4 ทอด — จำนวนทอด = ระยะทางจาก weight ตัวนั้นไปถึง cost

ลองไล่ทีละทอดของสมการล่างเพื่อให้เห็นว่ามันไม่ใช่สูตรที่ท่องจำ แต่คือ "เส้นทางเดิน": \(\theta^{[1]}\) ส่งผลต่อ \(z^{[1]}\) (ทอดที่ 4 นับจากขวา) → \(z^{[1]}\) ส่งผลต่อ \(a^{[1]}\) ผ่าน activation (ทอดที่ 3) → \(a^{[1]}\) ส่งผลต่อ \(z^{[2]}\) (ทอดที่ 2) → \(z^{[2]}\) ส่งผลต่อ \(J\) (ทอดที่ 1). อ่านจากซ้ายไปขวาในสมการคืออ่านจาก cost ย้อนกลับไปหา weight — ซึ่งก็คือชื่อ "back-propagation" นั่นเอง.

สไลด์สรุปว่า backpropagation ประกอบด้วย2 consecutive steps ต่อ 1 ตัวอย่าง: Forward Computation — "Find \(h_\theta(x)\) from left to right" คือไล่คำนวณจาก input ไป output เพื่อให้ได้ค่าทำนาย; และ Backward Computation — "Propagating error from right to left to find the error contribution from each connection weight in the network" คือไล่ error กลับจาก output มา input เพื่อหาว่าเส้นเชื่อมแต่ละเส้นรับผิดชอบความผิดพลาดเท่าไร. คำว่า consecutive (ต่อเนื่องกัน/เรียงลำดับ) สำคัญ: ทำ backward ก่อน forward ไม่ได้เด็ดขาด เพราะ backward ต้องใช้ค่า \(z, a\) ที่ forward ผลิตไว้.

2.1 Forward Computation: ต้องมีตัวเลขก่อนถึงจะย้อนกลับได้

เครือข่ายในหน้านี้คือ input 2 ตัว → hidden 3 node → output 1 node. สูตรพื้นฐานที่ใช้กับทุก node มีสองบรรทัดเท่านั้น:

บรรทัดแรกคือ "รวมข้อมูลเข้าแบบถ่วงน้ำหนัก" บรรทัดที่สองคือ "บีบผ่าน activation". จุดที่ต้องสังเกตคือผลรวมเริ่มที่ \(i=0\) ไม่ใช่ \(i=1\) — เพราะ index 0 คือ bias. สไลด์ทำสีแดงไว้ที่ \(x_0\) (bias unit ของ input layer) และ \(a_0^{[1]}\) (bias unit ของ hidden layer) ซึ่งเป็น node พิเศษที่มีค่าเท่ากับ 1 เสมอ ไม่ได้มาจากการคำนวณ และไม่มีเส้นเข้า. ที่ต้องทำสีเพราะนักเรียนมักลืม แล้วนับมิติของ \(\theta\) ผิดไปหนึ่งคอลัมน์.

เขียนสูตรของ output node ออกมาเต็มๆ ตามที่สไลด์ให้:

อ่าน index ให้ชัด (ระบบนี้มาจาก Andrew Ng ตามที่สไลด์หมายเหตุไว้): \(\theta_{12}^{[2]}\) หมายถึง "weight ใน layer 2 จาก node 2 ของ layer ก่อนหน้า ไปยัง node 1 ของ layer นี้" — ตัวเลขตัวแรกคือปลายทาง ตัวที่สองคือต้นทาง. ลำดับนี้ดูกลับด้านกับสามัญสำนึก แต่มันทำให้เขียนเป็นเมทริกซ์แล้วคูณได้พอดี (\(z = \theta a\)). ส่วน \(\theta_{10}^{[2]}\) ที่ต้นทางเป็น 0 คือ weight ของ bias — ซึ่งก็คือ \(\theta_{10}^{[2]}\times a_0^{[1]} = \theta_{10}^{[2]}\times 1\) นั่นเอง จึงเขียนสั้นๆ ได้แค่ \(\theta_{10}^{[2]}\).

2.2 นิยาม \(\delta\) และสูตรสำเร็จของสไลด์

ก่อนดูสูตร ต้องเข้าใจว่าทำไมถึงต้องประดิษฐ์ตัวแปรชื่อ \(\delta\) ขึ้นมาเลย. เหตุผลคือความประหยัด: สังเกตว่าในสมการ chain rule ทั้งสองอันของหน้า 6 เทอม \(\dfrac{\partial J}{\partial z^{[2]}}\) ปรากฏเหมือนกัน. ถ้าเครือข่ายมี weight 1,000 ตัว เราคงไม่อยากคำนวณเทอมนี้ซ้ำ 1,000 ครั้ง. จึงตั้งชื่อมันไว้ครั้งเดียวแล้วใช้ซ้ำ — ชื่อนั้นคือ \(\delta\).

สไลด์นิยามว่า \(\delta_j^{(l)}\) = "error of cost for \(a_j^{[l]}\) (unit \(j\) in layer \(l\))" และให้สูตรทางคณิตศาสตร์กำกับว่า

อ่านเป็นภาษาคน: "ถ้าดัน \(z\) ของ node นี้ขึ้นนิดเดียว cost จะเปลี่ยนไปเท่าไร" — ตัวเลขนี้คือ "ส่วนแบ่งความผิด" ของ node นั้น. โปรดสังเกตความไม่ตรงกันเล็กๆ ในสไลด์: คำบรรยายบอกว่าเป็น error ของ \(a_j^{[l]}\) แต่สูตรหารเทียบ \(z_j^{[l]}\). ตัวที่ใช้จริงทุกที่คือแบบที่หารเทียบ \(z\) (ถ้าใช้ \(a\) สูตร \(\delta^{[L]} = a^{[L]}-y\) จะไม่จริง) — จำแบบนี้ไปตอบข้อสอบ. สไลด์ยังนิยาม \(L\) = total number of layers in the network (not counting input layer) ⇒ เครือข่ายในรูปนี้มี \(L=2\).

จากนั้นสไลด์ให้สูตรสำเร็จ 4 บรรทัด (ยังไม่พิสูจน์ — พิสูจน์อยู่หน้า 10):

พร้อมกำกับว่าสำหรับ sigmoid \(g'(z^{[l]}) = a^{[l]}(1-a^{[l]})\) และสูตรแปลง \(\delta\) เป็น gradient:

output: error = ทำนาย − จริง. hidden: node นี้ "ยืม" error ของ layer ถัดไป × weight ที่เชื่อม × ความชันของ activation ของ node นี้เอง. gradient ของเส้นใดๆ = (error ปลายทาง) × (ค่าที่ไหลมาจากต้นทาง)

ทำไม \(\delta\) ของ hidden node ต้องมี 3 ตัวคูณพอดี — แต่ละตัวแปลว่าอะไร:

• \(\delta_1^{(2)}\) (error ที่ปลายทาง) — "ปลายทางที่ฉันส่งของไปให้ ผิดไปเท่าไร". ถ้าปลายทางไม่ผิดเลย ฉันก็ไม่ต้องรับผิด.
• \(\theta_{1j}^{[2]}\) (weight ของเส้นที่เชื่อม) — "ฉันมีอิทธิพลต่อปลายทางมากแค่ไหน". ถ้าเส้นนี้ weight = 0 ฉันไม่ได้ส่งอะไรไปเลย ⇒ ไม่รับผิดเลย.
• \(g'(z_j^{[1]})\) (ความชันของ activation ที่ตัวฉันเอง) — "ถ้าฉันขยับ \(z\) ของฉัน output \(a\) ของฉันจะขยับตามไหม". ถ้า activation อิ่มตัว (\(g'\approx0\)) ต่อให้ฉันขยับ \(z\) ก็ไม่มีอะไรเปลี่ยน ⇒ ปรับ weight ไปก็ไม่มีประโยชน์.

ส่วนเครื่องหมาย \(\top\) (transpose) และ \(*\) ในสไลด์: ในรูปแบบเวกเตอร์ \(\theta^{[l]\top}\delta^{[l]}\) คือคูณเมทริกซ์เพื่อกระจาย error ย้อนกลับ ส่วน \(*\) คือคูณทีละสมาชิก (element-wise) กับ \(g'\) ไม่ใช่คูณเมทริกซ์. ในสูตรรายตัวข้างบน \(\theta_{11}^{[2]}\) เป็นเลขตัวเดียว transpose จึงไม่ทำอะไรเลย — อาจารย์เขียน \(\top\) ไว้เพื่อให้รูปสูตรตรงกับเวอร์ชันเมทริกซ์ในหน้า 18.

2.3 กรณีเล็กที่สุด: Logistic Regression

ก่อนพิสูจน์สูตรกับเครือข่ายเต็ม สไลด์ย้อนกลับไปดูเครือข่ายที่เล็กที่สุดเท่าที่จะเป็นไปได้: node เดียว ซึ่งก็คือ logistic regression ที่เรียนมาแล้วใน Lesson 1. โครงสร้าง: รับ \(x_1, x_2\) (บวก \(x_0\) เป็น bias) → sigmoid node ตัวเดียว → output \(h_\theta(x)\) ที่ตีความเป็นคลาส \(\{0,1\}\). กฎอัปเดตของมันคือ

เทียบกับสูตร backprop ที่เพิ่งเห็น: เทอม \(\left(h_\theta(x)-y\right)\) คือ \(\delta\) ของ output พอดี และ \(x_j\) คือ \(a_j^{[0]}\) พอดี ⇒ gradient \(= \delta\times a^{[0]}\) ⇒ ตรงกับกฎ \(\dfrac{\partial J}{\partial\theta_{ij}^{[l]}} = a_j^{[l-1]}\delta_i^{(l)}\) เป๊ะ. ข้อสรุปที่ได้จากหน้านี้: backpropagation ไม่ใช่สูตรใหม่เอี่ยม มันคือการขยายสูตรของ logistic regression ให้ไล่ย้อนได้หลายชั้น — ถ้าเครือข่ายมีชั้นเดียว backprop จะยุบกลายเป็น logistic regression ทันที. นี่คือเหตุผลที่อาจารย์ใส่หน้านี้คั่นก่อนพิสูจน์: ให้เห็นว่าเรากำลังต่อยอดจากของที่รู้อยู่แล้ว ไม่ใช่เริ่มจากศูนย์.

2.4 พิสูจน์สูตรทีละขั้น (สไลด์หน้า 10)

สไลด์เริ่มด้วยการเขียนเครือข่ายทั้งอันเป็นสมการซ้อนกัน 5 บรรทัด ซึ่งคือ "computation graph" ของเรานั่นเอง:

บรรทัดขวาสุดคือหัวใจ: \(h\) คือ \(g\) ซ้อน \(g\) — composite function ชัดๆ จึงใช้ chain rule ได้. ต่อไปนี้คือการพิสูจน์ทั้งสามชิ้นแบบละเอียดทุกบรรทัด.

รูปแบบเมทริกซ์ (ที่ใช้ตอนเขียนโค้ด — ทำทุก node ใน layer พร้อมกัน):

เครื่องหมาย \(\odot\) คือคูณทีละสมาชิก (element-wise) ไม่ใช่คูณเมทริกซ์ — ตรงกับเครื่องหมาย \(*\) ที่สไลด์ใช้. ตรวจขนาดให้เห็นภาพ: layer 1 มี 3 node, layer 2 มี 1 node ⇒ \(\theta^{[2]}\) ขนาด \(1\times4\) ⇒ \(\theta^{[2]\top}\delta^{[2]}\) ขนาด \((4\times1)(1\times1)=4\times1\) แล้วตัดแถว bias (แถวแรก) ทิ้งเหลือ \(3\times1\) เพื่อคูณกับ \(g'(z^{[1]})\) ที่มีขนาด \(3\times1\). ทำไมต้องตัดแถว bias: เพราะ \(a_0^{[1]}\) เป็นค่าคงที่ 1 ไม่ได้มาจาก \(z\) ใดๆ จึงไม่มี \(\delta\) ของตัวเอง — นี่คือจุดที่โค้ดของนักเรียนพังบ่อยที่สุดเวลาเขียน backprop เอง.

3. ตัวอย่างคำนวณเต็มรูปแบบ: 2 Layer, 2 Training Examples

สไลด์หน้า 11–16 คือตัวอย่างที่อาจารย์เดินให้ดูในคาบ โดยเว้นตัวเลขไว้ทุกช่อง — นี่คือแบบฝึกหัดที่มีโอกาสออกสอบสูงที่สุดในบท. เราจะไล่ทีละหน้าและกรอกตัวเลขให้ครบ (ทุกค่าตรวจด้วย numpy แล้ว).

โจทย์: "Find partial derivative of each weight and do gradient descent for 1 iteration (2 examples) (Assume all sigmoid activation functions, \(y = \begin{bmatrix}1\\1\end{bmatrix}\))" — เครือข่าย input \(x_1,x_2\) (+ bias \(x_0=1\)) → hidden 2 node → output 1 node, sigmoid ทุก node, คำตอบจริงของทั้งสองตัวอย่างคือ 1.

ตัวเลขที่เขียนกำกับบนเส้นแต่ละเส้นคือค่า weight เริ่มต้น. อ่านออกมาเป็นเมทริกซ์ (แถว = node ปลายทาง; คอลัมน์ = bias, \(x_1\), \(x_2\)):

hidden node 1 ใช้เฉพาะ \(x_1\) (weight ของ \(x_2\) = 0); hidden node 2 ใช้เฉพาะ \(x_2\); output ใช้เฉพาะ hidden node 1

ค่า weight ที่เป็น 0 สามตัว (\(\theta_{12}^{[1]}=0\), \(\theta_{21}^{[1]}=0\), \(\theta_{12}^{[2]}=0\)) ไม่ได้ใส่มาเล่นๆ — มันจะทำให้เกิดผลลัพธ์ที่น่าตกใจสองอย่างข้างล่าง และนั่นคือสิ่งที่อาจารย์อยากให้เห็น.

หน้านี้กลับทิศลูกศรทุกเส้นเพื่อย้ำว่าตอนนี้เรากำลังส่ง "ความผิด" เดินสวนทางกลับ โดยใช้ weight ชุดเดิม (ยังไม่อัปเดต). คำนวณได้ดังนี้:

หน้านี้เพิ่มคำสั่งเดียวคือ "Accumulate gradients \(\Delta_{ij}^{(l)}\)" — แปลว่า อย่าเพิ่งอัปเดต weight ให้เอา gradient ของตัวอย่างนี้ไปบวกสะสมไว้ในตัวแปร \(\Delta\) ก่อน แล้วค่อยไปทำตัวอย่างที่ 2. เหตุผล: cost ที่เรานิยามไว้หน้า 1 คือค่าเฉลี่ยของทุกตัวอย่าง ดังนั้น gradient ของมันก็ต้องเป็นค่าเฉลี่ยของ gradient รายตัวอย่างเช่นกัน. ใช้สูตร \(\Delta_{ij}^{(l)} \mathrel{+}= a_j^{[l-1]}\delta_i^{(l)}\) กับตัวอย่างที่ 1:

ตัวอย่างที่ 2 เปลี่ยนแค่ \(x_2\) จาก 1 เป็น 2 (weight ยังเป็นชุดเดิม เพราะเรายังไม่ได้อัปเดต).

หน้าสุดท้ายของตัวอย่างระบุสองอย่าง: เฉลี่ยด้วย \(D_{ij}^{(l)} := \frac{1}{m}\Delta_{ij}^{(l)}\) แล้วอัปเดตด้วย gradient descent โดย "suppose alpha = 0.1".

4. Backpropagation Algorithm: สรุปเป็นขั้นตอนที่ใช้ได้ทุกโครงข่าย

ตัวอย่างใน §3 ทำกับเครือข่าย 2 layer 2 node. คำถามคือ "ถ้าเครือข่ายมี 5 layer ละ 100 node ต้องทำอย่างไร" — คำตอบคือทำเหมือนเดิมทุกอย่าง เพราะสูตรไม่ได้อ้างถึงขนาดของเครือข่ายเลย. สไลด์หน้า 17–18 จึงเขียนเป็นอัลกอริทึมทั่วไป.

สไลด์เริ่มจาก "Given a training set \((x^{(1)},y^{(1)}), (x^{(2)},y^{(2)}) \dots (x^{(m)},y^{(m)})\) and set \(\Delta_{ij}^{(l)} := 0\)" — บรรทัดนี้คือการล้างกระปุกสะสม gradient ให้เป็นศูนย์ก่อนเริ่มรอบใหม่ทุกครั้ง. ถ้าลืมล้าง gradient ของรอบก่อนจะบวกทบเข้ามาเรื่อยๆ จนก้าวใหญ่เกินจริง (บั๊กคลาสสิกของคนเขียน backprop เอง และเป็นเหตุผลที่ PyTorch ต้องเรียก optimizer.zero_grad() ทุกรอบ).

จากนั้นวนทุกตัวอย่าง \(i = 1\) ถึง \(m\) แล้วทำสองขั้น: (1) "Set \(a^{[0]} := x\)" — ตั้งชื่อ input ว่าเป็น activation ของ layer 0 เพื่อให้สูตรเดียว \(\partial J/\partial\theta_{ij}^{[l]} = a_j^{[l-1]}\delta_i^{(l)}\) ใช้ได้กับ layer แรกด้วย; (2) ทำforward computation เพื่อหา \(h_\theta(x)\) (หรือ \(a^{[L]}\)). สไลด์แสดงตัวอย่างเครือข่าย 3 layer เต็มๆ ว่าไล่อย่างไร:

วงเล็บ "(add bias)" ที่สไลด์เขียนกำกับไว้สองครั้งคือขั้นตอนที่คนลืมบ่อยที่สุด: หลังคำนวณ \(a^{[l]}\) เสร็จ ต้องแปะเลข 1 เข้าไปด้านหน้าเวกเตอร์ ก่อนส่งเข้า layer ถัดไป ไม่งั้นมิติจะไม่ตรงกับ \(\theta^{[l+1]}\) ที่มี \(s_l+1\) คอลัมน์.

หน้านี้ต่อจากขั้นที่ 2 ด้วยขั้นที่ 3 และ 4. ขั้นที่ 3: "compute the error \(\delta^{(L)} = a^{[L]} - y^{(i)}\)" — error ที่ชั้นนอกสุด. ขั้นที่ 4: ทำbackward computation "to measure the error contribution from each connection weight" โดยคำนวณ \(\delta^{(L)}, \delta^{(L-1)}, \dots, \delta^{(1)}\) ตามลำดับย้อนกลับด้วยสูตร

แล้วสะสมและเฉลี่ย:

และปิดท้ายด้วย gradient descent \(\theta_{ij}^{[l]} := \theta_{ij}^{[l]} - \alpha\frac{\partial J(\theta)}{\partial\theta_{ij}^{[l]}}\) ทำซ้ำจนลู่เข้า.

กล่อง "Intuition" ที่มุมล่างขวาคือประโยคที่ควรท่องได้: "update weights that minimize the final loss. So if some weight leads to the node that largely contributes to the final loss (\(\delta_{\text{destination}}\) is large), the algorithm will calculate larger gradient for gradient descent to adjust the weight." — weight ที่ชี้ไปยัง node ที่ก่อความเสียหายมาก จะได้ gradient ใหญ่ และถูกปรับแรง. ลองกับตัวเลขใน §3: \(\delta^{(2)} = -0.293\) (ใหญ่) ส่งผลให้ \(D_{11}^{(2)} = -0.258\) (ใหญ่ตาม) ⇒ \(\theta_{11}^{[2]}\) ขยับ 0.0258; ส่วน \(\delta_2^{(1)} = 0\) (ไม่มีส่วนผิด) ⇒ gradient 0 ⇒ ไม่ขยับเลย. นี่คือความหมายของคำว่า "ส่วนแบ่งความผิด" อย่างเป็นรูปธรรม.

เรียบเรียงเป็นขั้นตอนที่จำไปสอบได้:

1. ขั้นที่ 1 — เริ่มต้น

   ตั้ง \(\Delta_{ij}^{(l)} := 0\) ทุกตัว

2. ขั้นที่ 2 — วนทุกตัวอย่างฝึก \((x^{(i)}, y^{(i)})\): Forward

   \(a^{[0]} = x\); คำนวณ \(z^{[l]} = \theta^{[l]}a^{[l-1]},\ a^{[l]} = g(z^{[l]})\) (เติม bias) ไปจนถึง \(a^{[L]}\)

3. ขั้นที่ 3 — Error ที่ output
   $$\delta^{(L)} = a^{[L]} - y$$
4. ขั้นที่ 4 — ส่งย้อนกลับ \(l = L, L-1, \dots, 2\)
   $$\delta^{(l-1)} = \left(\theta^{[l]\top}\delta^{(l)}\right)\odot g'\!\left(z^{[l-1]}\right)$$
5. ขั้นที่ 5 — สะสม
   $$\Delta_{ij}^{(l)} \mathrel{+}= a_j^{[l-1]}\,\delta_i^{(l)}$$
6. ขั้นที่ 6 — หลังครบทุกตัวอย่าง: เฉลี่ยแล้วอัปเดต
   $$D_{ij}^{(l)} = \frac{1}{m}\Delta_{ij}^{(l)},\qquad \theta_{ij}^{[l]} := \theta_{ij}^{[l]} - \alpha\,D_{ij}^{(l)}$$

ตัวอย่างใน §3 คือการรันอัลกอริทึมนี้ตรงๆ 1 รอบด้วย \(m=2, L=2\).

4A. ใช้งานจริง: Autodiff, มิติพารามิเตอร์, การสุ่มค่าเริ่มต้น, Unrolling

สี่หน้าถัดไป (19–22) คือ "เรื่องที่ต้องรู้ตอนลงมือทำจริง" ซึ่งข้อสอบเติมโค้ดชอบหยิบไปถาม.

4A.1 จาก Backpropagation สู่ Automatic Differentiation (หน้า 19)

ข่าวดีของหน้านี้: "Modern deep-learning frameworks do not require us to manually derive every gradient" — เฟรมเวิร์กสมัยใหม่คำนวณอนุพันธ์ให้อัตโนมัติผ่าน computational graph โดยใช้ Chain Rule ตัวเดียวกับที่เราเพิ่งเรียน. เรายังต้องเข้าใจ backprop เพื่อ debug และเพื่อสอบ แต่ไม่ต้องหาอนุพันธ์ด้วยมือทุกครั้ง.

สไลด์แยก AD เป็นสองโหมดซึ่งเป็นจุดที่ข้อสอบชอบสลับ:

เหตุผลที่ deep learning เลือก reverse-mode อยู่ในประโยคที่สไลด์ทำตัวหนา: "Neural networks typically have many parameters → one scalar loss, making reverse-mode particularly suitable." — ลองคิดเป็นตัวเลข: ถ้าโมเดลมีพารามิเตอร์ 1,000,000 ตัวและ loss 1 ตัว, forward-mode ต้องรัน 1,000,000 รอบ (รอบละหนึ่งพารามิเตอร์) ส่วน reverse-mode รันรอบเดียวได้ครบทุกอนุพันธ์. นี่คือเหตุผลเชิงประสิทธิภาพทั้งหมดของ backpropagation. สไลด์สรุปความสัมพันธ์ไว้ชัด: "Reverse-mode autodiff is the general computational technique; backpropagation is its application to efficiently compute gradients through a neural network" — reverse-mode AD คือเทคนิคทั่วไป ส่วน backprop คือการเอาเทคนิคนั้นมาใช้กับเครือข่ายประสาท.

y_pred = model(x)          # forward pass
loss = criterion(y_pred, y)
loss.backward()            # reverse-mode autodiff / backprop
optimizer.step()           # update parameters

ผลลัพธ์ที่คาด: โค้ด 4 บรรทัดนี้ไม่พิมพ์อะไรออกมา — ผลของมันคือค่า loss (ตัวเลขเดียว ลดลงเรื่อยๆ ตามรอบ) และพารามิเตอร์ของ model ที่ถูกแก้ไขในที่ (in-place). สไลด์ไม่ได้แสดง output ของบล็อกนี้ จึงไม่มีตัวเลขให้อ้าง.

4A.2 Dimension of Parameters: สูตร b × (a+1) (หน้า 20)

เครือข่ายในหน้านี้คือ input 2 → hidden 3 → output 1. สไลด์กางเมทริกซ์ออกมาให้เห็นทุกช่อง:

นับตามจริง: \(\theta^{[1]}\) มี 3 แถวเพราะ hidden มี 3 node และมี 3 คอลัมน์เพราะ input มี 2 ตัวบวก bias อีก 1; \(\theta^{[2]}\) มี 1 แถวเพราะ output มี 1 node และ 4 คอลัมน์เพราะ hidden 3 node บวก bias. สรุปเป็นกฎทั่วไปตามที่สไลด์เขียน: ถ้า layer \(l-1\) มี \(a\) unit (ไม่นับ \(x_0\)) และ layer \(l\) มี \(b\) unit แล้วมิติของ \(\theta^{[l]}\) คือ \(b\times(a+1)\).

จำนวนแถว = จำนวน node ที่รับของ; จำนวนคอลัมน์ = จำนวน node ที่ส่งของ + 1 ช่องสำหรับ bias

4A.3 Parameters Initialization: ทำไมห้ามเริ่มที่ศูนย์ (หน้า 21)

เครือข่ายในหน้านี้มี weight เป็น 0 ทุกเส้น — และนั่นคือหายนะ. สไลด์อธิบายว่าการไม่สุ่มพารามิเตอร์ "might not capture interesting functions" ซึ่งเกิดอาการที่เรียกว่า redundant hidden units — hidden unit ที่ซ้ำซ้อน คือมีหลาย node แต่ทุก node คำนวณสิ่งเดียวกันเป๊ะ จึงเท่ากับมี node เดียว. ทางแก้คือ "Randomly initialize the weights, you break the symmetry and allow backpropagation to train a diverse team of neurons".

มาดูว่ามันพังอย่างไรด้วยตัวเลขจริง (เครือข่ายเดียวกับหน้า 21: \(x=(1,1)\), \(y=1\), weight ทุกตัวเป็น 0, sigmoid, \(\alpha=0.5\)):

อ่านตารางนี้ให้ออก: ค่า \(h\) ก็ลู่เข้าหา 1 อยู่นะ ดูเหมือนเทรนได้ — แต่แถว 1 กับแถว 2 ของ \(\theta^{[1]}\) เท่ากันทุกช่องทุกรอบ และ \(\theta_{11}^{[2]} = \theta_{12}^{[2]}\) ตลอดกาล. เหตุผลเชิงกลไก: เมื่อ weight เท่ากัน \(z_1^{[1]} = z_2^{[1]}\) ⇒ \(a_1^{[1]} = a_2^{[1]}\) ⇒ \(\delta_1^{(1)} = \delta_2^{(1)}\) ⇒ gradient เท่ากัน ⇒ อัปเดตเท่ากัน ⇒ ยังเท่ากันต่อไป. hidden 2 node ทำงานได้เท่ากับ 1 node เป๊ะ — ต่อให้ใส่ 100 node ก็ยังได้ความสามารถเท่า 1 node. นี่คือความหมายของ "redundant hidden units" และของคำว่า symmetry ที่ต้อง "break".

ทางแก้ที่สไลด์เสนอ (ในกรอบ "Initial Solution! (Advance solution later)"): สุ่มพารามิเตอร์แต่ละตัวเป็นค่าเล็กๆ ใกล้ศูนย์ คือ \(-\varepsilon < \theta_{ij}^{[l]} < \varepsilon\). คำว่า "advance solution later" หมายถึงวิธีที่ดีกว่า (Xavier / He initialization) ที่จะสอนใน Lesson 5 — แค่ "เล็ก" อย่างเดียวยังไม่พอสำหรับเครือข่ายลึก.

W = np.zeros((L_out, 1 + L_in))
W = np.random.rand(L_out, 1 + L_in) * 2 * epsilon_init - epsilon_init

ผลลัพธ์ที่คาด (รันจริงด้วย L_in=2, L_out=10, epsilon_init=0.12, seed=1): W.shape = (10, 3), ค่าต่ำสุด \(-0.1200\) ค่าสูงสุด \(0.1124\) — กระจายอยู่ในช่วง \([-0.12, 0.12)\) และไม่มีสองแถวใดเหมือนกัน ⇒ symmetry ถูกทำลายเรียบร้อย.

4A.4 Unrolling Parameters: ยัด θ ทุกตัวลงเวกเตอร์เดียว (หน้า 22)

ปัญหาที่หน้านี้แก้: ไลบรารี optimizer แบบคลาสสิก (เช่น scipy.optimize.minimize) รับพารามิเตอร์เป็นเวกเตอร์ 1 มิติก้อนเดียว ไม่ใช่รายการของเมทริกซ์. แต่เครือข่ายของเรามี \(\theta^{[1]}\) ขนาด \(10\times3\) และ \(\theta^{[2]}\) ขนาด \(1\times11\) คนละรูป. ทางออกคือ "unroll" — คลี่ทุกเมทริกซ์เป็นแถวยาวแล้วต่อกัน ส่งเข้า optimizer และเมื่อต้องใช้งานก็ "roll back" กลับเป็นรูปเดิม.

# Unroll parameters
nn_params = np.concatenate([Theta1.ravel(), Theta2.ravel()])

# Get Theta1 and Theta2 back from initial_nn_params
Theta1 = np.reshape(nn_params[:hidden_layer_size * (input_layer_size + 1)],
                    (hidden_layer_size, (input_layer_size + 1)))

Theta2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):],
                    (num_labels, (hidden_layer_size + 1)))

ผลลัพธ์ที่คาด (รันจริงด้วย input_layer_size=2, hidden_layer_size=10, num_labels=1): nn_params.shape = (41,); หลัง reshape กลับได้ Theta1.shape = (10, 3) และ Theta2.shape = (1, 11) ที่มีค่าเท่ากับต้นฉบับทุกช่อง (ตรวจด้วย np.allclose ได้ True ทั้งคู่).

5. Activation Function คืออะไร และอยู่ตรงไหนของเครือข่าย

ตลอด §2–§4 เราเขียน \(g\) ไว้เฉยๆ โดยไม่ถามว่ามันคือฟังก์ชันอะไร. ตอนนี้ถึงเวลาแล้ว เพราะ \(g'\) เป็นตัวคูณอยู่ในสูตร \(\delta\) ของทุก layer — เลือก \(g\) ผิด gradient ตายทั้งเครือข่าย.

นิยามที่อาจารย์ทำสีไว้: activation function คือ nonlinear function ที่ "transforms or compresses the weighted and summed input values in a node, yielding the neuron's activation" — แปลง/บีบค่าที่รวมแบบถ่วงน้ำหนักมาแล้ว ให้กลายเป็น activation ของ neuron. คำว่า "compresses" อธิบายพฤติกรรมของ sigmoid/tanh ได้ดี: ไม่ว่า \(z\) จะเป็น 1,000 หรือ −1,000 ผลลัพธ์ถูกบีบให้อยู่ในช่วงแคบๆ เสมอ.

หน้านี้ซูมเข้าไปดูภายใน node หนึ่งตัวเพื่อแยกองค์ประกอบสามอย่างให้เห็นชัด: Bias Unit 𝑥₀ คือ input พิเศษที่มีค่า 1 เสมอ, Weight θ10[1], θ11[1], θ12[1] คือตัวคูณของแต่ละเส้นที่เข้ามา (สามตัวเพราะมี bias + \(x_1\) + \(x_2\)) และ g (สไลด์ทำสีแดงตัวหนา) คือ activation. การคำนวณภายใน node เป็นสองจังหวะเสมอ:

ทำไมต้องมี bias unit: ถ้าไม่มี \(x_0\) สมการ \(z = \theta_{11}x_1 + \theta_{12}x_2\) จะถูกบังคับให้ผ่านจุดกำเนิดเสมอ — เมื่อ input เป็น 0 ทั้งหมด \(z\) ต้องเป็น 0 และ \(a = g(0) = 0.5\) ตายตัว. bias คือตัวเลื่อนเส้นแบ่ง ทำให้ node "มีความเห็นของตัวเอง" ได้แม้ไม่มี input. เปรียบเทียบกับสมการเส้นตรง \(y = mx + c\): bias คือ \(c\) ส่วน weight คือ \(m\) — ถ้าไม่มี \(c\) เส้นตรงทุกเส้นต้องลากผ่านจุด (0,0).

สไลด์แบ่ง activation ออกเป็นสองที่ใช้งานซึ่งใช้คนละเกณฑ์ในการเลือก และนี่คือโครงของ §5 ถึง §6 ทั้งหมด:

• Activation Function at the Hidden Layers — เลือกตาม "gradient ไหลดีไหม" (หน้า 24–35, §5–§5C)
• Activation Function at the Output Layer — เลือกตาม "ชนิดของงาน" (หน้า 36–38, §6)

เหตุผลที่ hidden layer ต้องใช้ฟังก์ชันไม่เชิงเส้น สไลด์เขียนไว้ตรงๆ: "In order to learn more complex relationships, activation functions should expose non-linearity into the output of a neuron" (จะพิสูจน์ใน §5C). รายการที่สไลด์ให้มี 4 ตัวหลัก + กลุ่มขยาย: Sigmoid, Tanh, ReLU, Leaky ReLU และ "More activation functions such as ELU, SELU…".

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

นี่คือ gradient ของ \(\theta_{11}^{[1]}\) ที่เราพิสูจน์ไปแล้วใน §2 — และ \(g'\) นั่งอยู่เป็นตัวคูณตัวหนึ่งในนั้น. ตีความเป็นตัวเลข: ถ้าใช้ sigmoid และ \(z_1^{[1]}\) บังเอิญเป็น 4, ค่า \(g'(4) = 0.0177\) ⇒ gradient ของ weight ตัวนี้ถูกหั่นเหลือ 1.77% ทันทีในชั้นเดียว. ถ้าใช้ ReLU ที่ \(z=4\), \(g'=1\) ⇒ gradient ผ่านไปเต็มๆ. การเลือก activation จึงคือการเลือกว่าจะให้ gradient ไหลย้อนได้ดีแค่ไหน ไม่ใช่แค่เรื่องรูปร่างกราฟสวยงาม.

เครือข่ายตัวอย่างในหน้านี้คือ Shallow Neural Network: input 2 → hidden 10 (\(a_1^{[1]}\) ถึง \(a_{10}^{[1]}\)) → output 1 ซึ่งเป็นเครือข่ายเดียวกับที่จะใช้ในแบบฝึกหัดหน้า 47–48 และในโจทย์นับพารามิเตอร์หน้า 42. คำว่า "shallow" (ตื้น) หมายถึงมี hidden layer ชั้นเดียว ตรงข้ามกับ "deep" ที่มีหลายชั้น.

5A. Sigmoid และ Tanh: อนุพันธ์ ข้อดี และปัญหา zero-centered

5A.1 Sigmoid และอนุพันธ์ (หน้า 25)

สไลด์หน้านี้ไล่พิสูจน์ \(\sigma'\) ทีละบรรทัดจนได้รูปสวยงาม \(\sigma(z)(1-\sigma(z))\). เหตุผลที่อาจารย์ยอมเสียทั้งหน้าให้การพิสูจน์นี้: รูปสุดท้ายทำให้คำนวณอนุพันธ์ได้จากค่า \(a\) ที่ forward คำนวณไว้แล้ว ไม่ต้องคำนวณ \(e^{-z}\) ใหม่ — ประหยัดมหาศาลเมื่อมี node เป็นล้าน.

อนุพันธ์ของ sigmoid มีค่าสูงสุดเพียง 0.25 ที่ \(z=0\) (เพราะ \(0.5\times0.5 = 0.25\) และผลคูณ \(a(1-a)\) ใหญ่สุดเมื่อ \(a=0.5\)) และหดเร็วเมื่อ \(|z|\) โต — ที่ \(z=\pm2\) เหลือ 0.105 ซึ่งต่ำกว่าครึ่งของยอดแล้ว. ถ้า sigmoid ต่อกัน \(L\) layer gradient จะถูกคูณด้วยตัวเลข \(\le0.25\) ซ้ำ \(L\) ครั้ง — เช่น 10 layer ⇒ \(0.25^{10} \approx 9.5\times10^{-7}\) คือเกือบหนึ่งในล้าน. นี่คือรากของ vanishing gradient ที่ Lesson 5 จะลงลึก.

5A.2 Tanh และอนุพันธ์ (หน้า 26)

สไลด์ใช้ quotient rule แบบเดียวกับ sigmoid แต่เศษและส่วนเป็นฟังก์ชันทั้งคู่ จึงยาวกว่า. ไล่ตามทุกบรรทัด:

5A.3 Sigmoid vs Tanh (หน้า 27)

อาจารย์สรุปการเปรียบเทียบไว้เป็นสามบรรทัดใต้กราฟ: "Sigmoid → Output is in [0,1]", "Tanh → Output is in [-1,1] (outputs - zero-centered)", และ "Both sigmoid and tanh slow when x is too large/small".

อ่านกราฟคู่ขวา (กราฟอนุพันธ์) ด้วยตัวเลขจริง: ที่ \(x=0\) เส้น tanh แตะ 1.00 ส่วนเส้น sigmoid แตะแค่ 0.25 — ต่างกัน 4 เท่า. เลยออกไปที่ \(|x|\ge4\) ทั้งสองเส้นแบนติดศูนย์ (sigmoid 0.0177, tanh 0.0013) ⇒ ตรงนั้นคือ "dead zone" ที่ gradient แทบไม่มี. นี่คือความหมายเชิงตัวเลขของคำว่า "slow when x is too large/small" — ไม่ใช่ว่าโค้ดทำงานช้า แต่คือการเรียนรู้ช้า เพราะ gradient เล็กจนแทบไม่ขยับ weight.

คำว่า "zero-centered" ของ tanh หมายความว่าอะไร: output ของ tanh กระจายรอบ 0 (ได้ทั้งบวกและลบ) ส่วน sigmoid ให้ค่าบวกเสมอ (0 ถึง 1) มีค่าเฉลี่ยราว 0.5. ฟังดูเป็นเรื่องเล็ก แต่หน้าถัดไปอธิบายว่ามันทำให้การเทรนช้าลงจริงๆ.

5A.4 ทำไม "ไม่ zero-centered" ถึงเป็นปัญหา (หน้า 28)

หน้านี้วางสามอย่างไว้ด้วยกัน: สูตร gradient ของ layer 2, กฎอัปเดต gradient descent, และภาพวาดมือของเส้นทางที่วิ่งซิกแซกจากจุด src ไปจุด tgt ในระนาบ \((w_1, w_2)\). ทั้งสามอย่างเชื่อมกันเป็นเหตุผลเดียว ดังนี้:

จากสูตร \(\dfrac{\partial J}{\partial\theta^{[2]}} = \big(h_\theta(x)-y\big)a^{[1]}\) สังเกตว่า gradient ของ weight ทุกเส้นที่เข้า node เดียวกันมี \((h-y)\) เป็นตัวคูณร่วม ต่างกันแค่ \(a_j^{[1]}\). ถ้า activation เป็น sigmoid ⇒ \(a_j^{[1]} > 0\) ทุกตัว ⇒ gradient ของ weight ทุกตัวในแถวนั้นมีเครื่องหมายเดียวกันเสมอ (ตามเครื่องหมายของ \(h-y\)).

ลองกับตัวเลขจาก §3: \(\delta^{(2)} = -0.293\), \(a^{[1]} = (1,\ 0.8808,\ 0.8808)\) ⇒ gradient = \((-0.293,\ -0.258,\ -0.258)\) — ลบทั้งสามตัว ⇒ weight ทุกตัวเพิ่มพร้อมกัน. รอบถัดไปถ้าทำนายเกิน gradient จะบวกทั้งแถว ⇒ weight ทุกตัวลดพร้อมกัน. ผลคือทิศทางที่เดินได้มีแค่ "ขึ้นทั้งคู่" หรือ "ลงทั้งคู่" (ควอดรันต์ที่ 1 กับ 3 ของระนาบ \((w_1,w_2)\)) — แต่ถ้าจุดหมายอยู่ในทิศ "\(w_1\) ขึ้น \(w_2\) ลง" เราไปตรงๆ ไม่ได้ ต้องเดินซิกแซกสลับไปมาทีละก้าวเล็กๆ ซึ่งก็คือเส้นทางที่วาดไว้ในภาพ. ถ้าใช้ tanh ที่ \(a\) มีทั้งบวกและลบ เครื่องหมายของ gradient แต่ละตัวอิสระต่อกัน ⇒ เดินเฉียงตรงไปหาเป้าได้ทันที.

activation ที่ให้ค่าบวกล้วนบังคับให้ weight ทุกตัวในแถวเดียวกันขยับทิศเดียวกัน — เหมือนพายเรือที่ทุกคนต้องพายข้างเดียวกันเสมอ จะเลี้ยวก็ต้องสลับไปมา

สไลด์อ้างลิงก์ StackExchange ("why are non-zero-centered activation functions a problem in backpropagation") และหน้า 26 อ้างบทความของ LeCun ("Why zero-mean output") เป็นแหล่งอ่านต่อ — นี่คือเหตุผลทั้งหมดที่ตารางหน้า 32 ให้ "outputs - zero-centered" เป็นข้อดีของ tanh และ "outputs - not zero-centered" เป็นข้อเสียของ sigmoid.

5A.5 ผลการทดลองจริง: sigmoid vs tanh (หน้า 29)

อาจารย์รันเครือข่ายเดียวกันบนชุดข้อมูล Spiral สองครั้ง เปลี่ยนแค่ activation ของ hidden layer แล้ววางผลเทียบกัน. ตัวเลขที่ต้องจำ:

# Comparison between sigmoid and tanh  (Spiral dataset, network เดียวกัน, 6000 iterations)
sigmoid   # Training Set Accuracy: 98.666667   gradient อยู่ในช่วงประมาณ -0.4 ถึง 0.4
tanh      # Training Set Accuracy: 99.833333   gradient อยู่ในช่วงประมาณ -1.5 ถึง 1.5

ผลลัพธ์ที่คาด (อ่านจากสไลด์): sigmoid = 98.666667, tanh = 99.833333. และกราฟ gradient ก็ยืนยันการพิสูจน์ในหัวข้อก่อนหน้าพอดี: gradient ของ sigmoid หนาแน่นอยู่ในช่วงแคบ \(\pm0.4\) ในขณะที่ tanh แกว่งถึง \(\pm1.5\) — อนุพันธ์ยอด 1 เทียบกับยอด 0.25 แสดงตัวออกมาเป็นขนาด gradient จริงๆ และ gradient ที่ใหญ่กว่าก็แปลว่า weight ขยับได้เร็วกว่าในแต่ละรอบ ซึ่งเห็นได้จากเส้น cost ของ tanh ที่ดิ่งเร็วกว่า.

5B. ReLU, Leaky ReLU และตารางเปรียบเทียบ activation ทั้งสี่

5B.1 ReLU (หน้า 30)

ReLU คือฟังก์ชันที่ง่ายที่สุดในบทนี้ — "ถ้าติดลบให้เป็น 0 ถ้าไม่ติดลบก็ปล่อยผ่าน":

ลองใส่ตัวเลข: \(f(-3)=0\), \(f(-0.1)=0\), \(f(0)=0\), \(f(2)=2\), \(f(1000)=1000\). และอนุพันธ์: \(f'(-3)=0\), \(f'(2)=1\), \(f'(1000)=1\).

ทำไมอนุพันธ์ที่เป็น 1 คงที่ถึงเปลี่ยนเกม: ย้อนกลับไปที่สูตร \(\delta^{(l-1)} = (\theta^{[l]})^\top\delta^{(l)} * g'(z^{[l-1]})\). ถ้า \(g'=1\) เสมอในฝั่งบวก ตัวคูณนี้ไม่หั่น gradient เลย — คูณ 1 กี่ครั้งก็ยังเป็นตัวมันเอง. เทียบกันตรงๆ กับ sigmoid ในเครือข่าย 10 layer: sigmoid ให้ \(0.25^{10} = 9.5\times10^{-7}\) ส่วน ReLU (สมมติทุก node อยู่ฝั่งบวก) ให้ \(1^{10} = 1\) — ต่างกันประมาณหนึ่งล้านเท่า. นี่คือเหตุผลตัวเลขที่ ReLU ทำให้เทรนเครือข่ายลึกได้จริง.

ข้อเสียที่มากับความเรียบง่าย: ในฝั่ง \(x<0\) อนุพันธ์เป็น 0 สนิท ⇒ ถ้า node หนึ่งบังเอิญมี \(z<0\) สำหรับข้อมูลทุกตัว มันจะไม่ได้รับ gradient เลยตลอดกาล (เรียกว่า "dying ReLU"). ตารางหน้า 32 เรียกอาการนี้ว่า "information loss on \(x<0\)". อีกข้อคือ output ไม่มีขอบบน (\([0,\infty]\)) ซึ่งตารางเรียกว่า "output can be Infinite".

5B.2 Leaky ReLU (หน้า 31)

Leaky ReLU แก้ปัญหา "ฝั่งลบตาย" ด้วยการให้ความชันเล็กๆ แทนที่จะเป็น 0 สนิท:

ตัวเลขเทียบกัน: ที่ \(x=-5\) ReLU ให้ \(f=0,\ f'=0\) (ตายสนิท) ส่วน Leaky ReLU ให้ \(f=-0.05,\ f'=0.01\) — เล็กมากแต่ไม่ใช่ศูนย์ ⇒ ยังมี gradient ไหลกลับผ่านได้ ⇒ node มีโอกาสฟื้นกลับมาใช้งานได้. ราคาที่จ่ายคือ output ขยายออกทั้งสองฝั่ง \([-\infty, \infty]\) ซึ่งตารางหน้า 32 ระบุเป็นข้อเสีย "output can be Infinite".

ReLU ปิดประตูฝั่งลบสนิท; Leaky ReLU แง้มประตูไว้ 1% เพื่อให้ gradient เล็ดลอดกลับมาได้

5B.3 ตารางเปรียบเทียบทั้งสี่ (หน้า 32) — หน้าที่ออกสอบบ่อยที่สุดของ §5

นี่คือตารางเดียวกับในสไลด์ ถอดออกมาเป็นข้อความให้อ่านได้โดยไม่ต้องเพ่งรูป (ข้อความในช่องเป็นคำของอาจารย์):

ข้อดีของ ReLU ที่อาจารย์ทำสีแดงไว้ช่องเดียวในตารางทั้งตารางคือ fast calculation (better convergence) — คำนวณเร็ว จึงลู่เข้าเร็วกว่า. คำว่า "เร็ว" มีสองความหมายซ้อนกัน: (1) เร็วเชิงเครื่อง — ReLU คือการเทียบกับ 0 หนึ่งครั้ง ไม่ต้องคำนวณ \(e^{-x}\) ซึ่งเป็นการยกกำลังที่แพงกว่ามาก; (2) เร็วเชิงการเรียนรู้ — เพราะ \(g'=1\) ไม่หั่น gradient จึงเดินลงเขาได้ก้าวใหญ่กว่า ตามที่เห็นในกราฟ cost หน้า 34 ที่ ReLU ลู่เข้าภายใน ~1000 รอบขณะที่ sigmoid/tanh ใช้หลายพันรอบ.

จุดที่อาจารย์เองก็ตั้งข้อสงสัยไว้: ในช่อง Disadvantages ของ ReLU มีข้อความ "information loss on x<0" ตามด้วยเครื่องหมายคำถามสีแดง "??" — อ่านได้ว่าอาจารย์กำลังบอกว่าข้อเสียข้อนี้ยังถกเถียงได้: การตัดค่าลบทิ้งดูเหมือนสูญเสียข้อมูล แต่ในทางปฏิบัติมันคือกลไกที่ทำให้เครือข่าย "เลือกเปิดเฉพาะบาง node" (sparsity) ซึ่งมักช่วยมากกว่าทำร้าย. คำตอบที่ปลอดภัยในข้อสอบ: ระบุตามตารางว่าเป็นข้อเสียที่สไลด์เขียนไว้ แต่รู้ด้วยว่าในทางปฏิบัติ ReLU ยังเป็น state of the art (หน้า 33).

ข้อสังเกตที่ควรเห็นจากตาราง: ช่อง Advantages ของ sigmoid และ tanh พูดถึง "ช่วง output เหมาะกับ classification" (คุณสมบัติของค่าที่ออกมา) ส่วนของ ReLU/Leaky ReLU พูดถึง "fast calculation" (คุณสมบัติของการคำนวณ) — สองตระกูลนี้เก่งคนละด้าน จึงเป็นที่มาของหลักการเลือกว่า hidden layer ใช้ตระกูล ReLU, output layer ใช้ sigmoid/softmax ซึ่งจะสรุปใน §6.

5B.4 ควรใช้ activation ตัวไหนที่ hidden layer (หน้า 33)

คำแนะนำหลักที่อาจารย์ทำสีไว้: • Rectified linear units (ReLU) "are the current state of the art because they have proven to work in many different situations" — ReLU คือมาตรฐานปัจจุบันของ hidden layer. เหตุผลเชิงกลไกที่สไลด์ให้: "Because the gradient of a ReLU is either zero or a constant, it is possible to reign in the vanishing exploding gradient issue. ReLU activation functions have shown to train better in practice than sigmoid activation functions."

แกะประโยคนี้ให้เป็นตัวเลข: อนุพันธ์ของ ReLU มีได้แค่ 0 หรือ 1 — ไม่มีค่ากลางๆ อย่าง 0.25 หรือ 0.0177. ผลคือเมื่อคูณต่อกันหลายชั้น ผลคูณเป็นได้แค่ 0 (ทางตัน) หรือ 1 (ผ่านเต็ม) ไม่มีการ "หดทีละนิดจนหายไป" แบบ \(0.25^{10}\) และไม่มีการ "โตทีละนิดจนระเบิด" แบบตัวคูณ > 1 ⇒ คุมได้ทั้ง vanishing และ exploding gradient ตามที่สไลด์ว่า.

Softplus — สไลด์เสนอเป็นรุ่นเรียบของ ReLU: "Softplus is considered to be the smooth version of the ReLU. It has quite a similar shape to the ReLU but differentiable everywhere on the graph."

ลองตัวเลขเทียบกับ ReLU เพื่อดูว่า "smooth" แปลว่าอะไร: ที่ \(x=-3\) ReLU ให้ 0 พอดี Softplus ให้ \(\ln(1+0.0498) = 0.0486\); ที่ \(x=0\) ReLU ให้ 0 Softplus ให้ \(\ln 2 = 0.693\); ที่ \(x=2\) ReLU ให้ 2 Softplus ให้ \(\ln(1+7.389) = 2.127\). เห็นได้ว่า Softplus เกาะติด ReLU ที่ปลายทั้งสองข้าง แต่โค้งมนตรงมุมหัก \(x=0\) ซึ่งเป็นจุดเดียวที่ ReLU หาอนุพันธ์ไม่ได้ทางคณิตศาสตร์ (ความชันซ้ายเป็น 0 ความชันขวาเป็น 1 ไม่เท่ากัน) — Softplus จึง "differentiable everywhere" ตามที่สไลด์ว่า. ในทางปฏิบัติ ReLU ยังชนะเพราะเร็วกว่ามาก และปัญหามุมหักที่ \(x=0\) เป๊ะๆ แทบไม่เกิดกับเลขทศนิยมจริง.

ถ้า ReLU ไม่เวิร์ค: สไลด์แนะให้ลอง leaky ReLU หรือญาติของมันคือ ELU, SELU, GELU (สไลด์เขียนว่า "or its variances such as ELU, SELU, GELU..") พร้อมลิงก์อ่านต่อที่ encord.com. ทั้งสามตัวนี้สไลด์ไม่ได้ให้สูตร — ข้อสอบจึงน่าจะถามแค่ระดับ "รู้จักชื่อและรู้ว่าเป็นทางเลือกเมื่อ ReLU มีปัญหา". ลำดับที่ควรจำ: ReLU ก่อนเสมอ → ถ้ามีปัญหา (เช่น node ตายเยอะ) ค่อยไป leaky ReLU → แล้วจึง ELU/SELU/GELU. แหล่งอ้างอิงของหน้านี้คือหนังสือ Getting started with deep learning ของ Adam Gibson และ Josh Patterson.

5B.5 ผลการทดลองสามตัวเทียบกัน (หน้า 34)

หน้านี้ขยายการทดลองของหน้า 29 โดยเพิ่ม relu เข้ามาเป็นคอลัมน์ที่สาม ใช้ชุดข้อมูล Spiral เดียวกัน:

# Comparison: same network on the Spiral dataset, only the hidden activation changes
sigmoid   # Training Set Accuracy:  98.666667   (6000 iterations, gradient ~ -0.4 .. 0.4)
tanh      # Training Set Accuracy:  99.833333   (6000 iterations, gradient ~ -1.5 .. 1.5)
relu      # Training Set Accuracy: 100.000000   (4000 iterations, gradient ~ -1.0 .. 1.0)

ผลลัพธ์ที่คาด (อ่านจากสไลด์): 98.666667 → 99.833333 → 100.000000. กราฟ gradient ของ relu มีลักษณะเฉพาะที่ควรสังเกต: มันกว้าง \(\pm1.0\) ในช่วงต้น แล้วยุบลงเกือบเป็นศูนย์หลังรอบที่ ~1000 ในขณะที่ของ sigmoid ยังแกว่งยาวไปจนถึงรอบ 5000 — แปลว่า relu หาคำตอบเจอแล้วจึงหยุดขยับ ส่วน sigmoid ยังคลำทางอยู่. เตือน: ตัวเลขเหล่านี้มาจากภาพในสไลด์โดยตรง ไม่ได้รันใหม่ (TensorFlow ไม่ได้ติดตั้งในเครื่องที่ใช้เตรียมบทเรียนนี้).

5C. ทำไม activation ต้องไม่เป็น Linear

สไลด์ตอบคำถามนี้ด้วยการลองทำจริง: สมมติ \(f(x)=x\) (linear — คือไม่ทำอะไรเลย) ทุก node ในเครือข่าย input 2 → hidden 3 → output 1 แล้วดูว่าได้อะไร.

Computation on layer 1 (สไลด์เขียนสามบรรทัด):

และเนื่องจาก \(f\) เป็น identity ⇒ \(a_j^{[1]} = f(z_j^{[1]}) = z_j^{[1]}\) (activation ไม่ได้แปลงอะไรเลย).

Computation on layer 2: \(z_1^{[2]} = \theta_{10}^{[2]} + \theta_{11}^{[2]}z_1^{[1]} + \theta_{12}^{[2]}z_2^{[1]} + \theta_{13}^{[2]}z_3^{[1]}\) — เมื่อแทน \(z_j^{[1]}\) ที่เป็นพหุนามดีกรี 1 ของ \(x_1,x_2\) เข้าไป แล้วรวมพจน์เหมือนกัน จะได้รูป

ตามที่สไลด์สรุปไว้ทุกตัวอักษร. หัวข้อบนหน้าระบุผลเสียตรงๆ: "Not capable to learn complex relationship (just output linear function)".

6. Activation ที่ Output Layer: Regression, Binary และ Softmax

ที่ hidden layer เราเลือก activation ตามเกณฑ์ "gradient ไหลดีไหม" (จึงเลือก ReLU). ที่ output layer เกณฑ์เปลี่ยนไปคนละเรื่อง: ค่าที่ออกมาต้องอยู่ในรูปที่ตีความได้ตรงกับงาน. ทำนายราคาบ้านแล้วได้ค่าในช่วง [0,1] ก็ใช้ไม่ได้; ทำนายความน่าจะเป็นแล้วได้ค่า 7.3 ก็ใช้ไม่ได้เช่นกัน.

สไลด์แบ่งเป็นสามกรณีตามชนิดของงาน และใส่ดอกจัน *** กำกับตัวเลือกที่แนะนำ ซึ่งเป็นจุดที่ข้อสอบชอบหยิบ:

ทำไม regression ใช้ linear ได้ทั้งที่ §5C เพิ่งบอกว่า linear ไม่ดี: เพราะข้อห้ามใน §5C เป็นเรื่องของ hidden layer ที่มีชั้นถัดไปมารวมต่อ (จึงยุบเป็นเส้นตรง). output layer เป็นชั้นสุดท้าย ไม่มีใครมารวมต่อแล้ว — ความไม่เชิงเส้นที่ hidden layer สร้างไว้ยังอยู่ครบ. ถ้าดันใส่ sigmoid ที่ output ของงาน regression ค่าทำนายจะถูกบีบอยู่ใน [0,1] ⇒ ทำนายราคาบ้าน 3 ล้านไม่ได้เลย.

หน้านี้อธิบายวิธีแรกของ multiclass: ใช้ sigmoid แยกทุก node. ขั้นแรกต้องแปลงคำตอบให้เป็น one-hot encoding ก่อน. ตัวอย่างในสไลด์ใช้ 4 คลาส และแปลงเวกเตอร์ \(y = [2,\ 1,\ 3,\ 0,\ \dots]^\top\) เป็นเมทริกซ์:

ทำไมต้อง one-hot: ถ้าปล่อยคำตอบเป็นตัวเลข 0,1,2,3 โมเดลจะเข้าใจผิดว่าคลาส 3 "มากกว่า" คลาส 1 สามเท่า และคลาส 2 อยู่ "ระหว่าง" คลาส 1 กับ 3 — ทั้งที่มันเป็นแค่ชื่อ (ฟุตบอล/บาสเกตบอล/เทนนิส/ปิงปอง ตามภาพลูกบอล 4 ลูกในสไลด์) ไม่มีลำดับ. one-hot ทำให้ทุกคลาสอยู่ห่างกันเท่ากันหมด และทำให้ output layer มี 1 node ต่อ 1 คลาสพอดี.

cost function ของวิธีนี้คือ cross-entropy ของหน้า 1 แต่บวกผลรวมอีกชั้นเพื่อไล่ทุกคลาส \(k\):

โดยที่ \(k\) = จำนวนคลาส output (สไลด์กำกับว่า "k is more than 2 classes"). อ่านให้ออก: ผลรวมชั้นนอก \(\sum_i\) ไล่ตัวอย่าง, ผลรวมชั้นใน \(\sum_k\) ไล่ node output. ในทางปฏิบัติแปลว่า "ทำ binary classification พร้อมกัน \(K\) ปัญหา" — node ที่ 1 ตอบว่า "ใช่ฟุตบอลไหม", node ที่ 2 ตอบว่า "ใช่บาสไหม" ฯลฯ แยกกันเป็นอิสระ. จุดอ่อนของวิธีนี้: เพราะแต่ละ node ตัดสินเองโดยไม่คุยกัน ผลรวมของ output ทั้งหมดจึงไม่จำเป็นต้องเท่ากับ 1 — อาจได้ \([0.9,\ 0.8,\ 0.1,\ 0.7]\) ซึ่งตีความเป็นความน่าจะเป็นของคลาสที่แยกขาดจากกันไม่ได้. นี่คือปัญหาที่หน้า 38 มาแก้.

สไลด์นิยามว่า Softmax คือ activation ของทั้ง output layer พร้อมกัน (ไม่ใช่ทีละ node) ที่ rescales outputs ให้ node ทั้งหมดบวกกันได้ 1 และคืนค่าเป็น probability distribution เหนือคลาสที่ "mutually exclusive" (แยกขาดจากกัน — เป็นได้แค่คลาสเดียว). สไลด์เสริมว่ามันคือ "A generalization of logistic regression for multi-class classification".

สูตรสองบรรทัดตามสไลด์: ตั้ง \(t_i = e^{z_i^{[L]}}\) แล้ว

คอมเมนต์ที่อาจารย์เขียนกำกับไว้ท้ายสูตร: "each \(a_i^{[L]}\) are normalized, and they add up to 1." — ทุกช่องถูก normalize แล้วและบวกกันได้ 1

ทำไมต้องใช้ exponential — สไลด์ให้เหตุผลไว้สองข้อ ใน note ที่ควรท่องได้: "The reason why using exponential is that some output might be negative – aka to logistic that mapping to [0,1] and it also amplifies the maximum value relative to the other values, forcing the model to be 'less neutral' toward prediction."

1. เหตุผลที่ 1 — จัดการค่าติดลบ

   logit อาจติดลบได้ เช่น \(z = [-1,\ -2]\). ถ้าหารด้วยผลรวมตรงๆ จะได้ \(-1/(-3) = 0.333\) และ \(-2/(-3)=0.667\) ⇒ คลาสที่คะแนนต่ำกว่ากลับได้ความน่าจะเป็นสูงกว่า — ผิดสิ้นเชิง. แต่ \(e^{x} > 0\) เสมอ ⇒ \(e^{-1}=0.3679,\ e^{-2}=0.1353\) ⇒ ได้ \([0.7311,\ 0.2689]\) ซึ่งเรียงลำดับถูกต้อง. นี่คือความหมายของ "aka to logistic that mapping to [0,1]".

2. เหตุผลที่ 2 — ขยายช่องว่างของตัวที่มากที่สุด ("less neutral")

   จากตัวอย่างข้างบน \(z=[1,3,0.5]\): ถ้าใช้สัดส่วนธรรมดา \(1/4.5, 3/4.5, 0.5/4.5 = [0.222, 0.667, 0.111]\) แต่ softmax ให้ \([0.111, 0.821, 0.067]\) — ตัวที่ชนะได้ส่วนแบ่งเพิ่มจาก 66.7% เป็น 82.1%. โมเดลจึง "กล้าฟันธง" มากขึ้นแทนที่จะตอบกลางๆ.

Loss ของ softmax ที่สไลด์ให้ ต่างจากของหน้า 37 ตรงที่มีเทอมเดียว:

เพราะสไลด์กำกับว่า \(y_k^{(i)} = 1\) only for the correct class, 0 otherwise ⇒ ในผลรวม \(\sum_k\) มีแค่พจน์เดียวที่ไม่เป็นศูนย์ คือพจน์ของคลาสที่ถูก. พูดง่ายๆ: cost = \(-\log(\)ความน่าจะเป็นที่โมเดลให้กับคำตอบที่ถูก\()\). จากตัวอย่างข้างบน ถ้าคำตอบจริงคือคลาสที่ 2: cost \(= -\ln 0.8214 = 0.1967\) (ต่ำ ดี); ถ้าคำตอบจริงคือคลาสที่ 3: cost \(= -\ln 0.0674 = 2.697\) (สูง โดนปรับหนัก). ไม่ต้องมีเทอม \((1-y)\log(1-h)\) เพราะการบังคับให้ผลรวมเป็น 1 อยู่แล้วทำให้การดันคลาสที่ถูกขึ้น อัตโนมัติ กดคลาสที่ผิดลง.

ภาพขวาของสไลด์ (Figure 10-9 จากหนังสือ Hands-on ML) แสดงสถาปัตยกรรมที่ใช้จริง: input layer → hidden layer (e.g., ReLU) → Softmax output layer — ตรงกับคำแนะนำรวมของบทนี้พอดี คือ ReLU ที่ hidden, softmax ที่ output สำหรับงาน multiclass.

6A. ประเมินและปรับปรุงโมเดล: Train / Validation / Test, Bias vs Variance

ถึงตรงนี้เราเทรนโมเดลเป็นแล้ว. คำถามถัดไปคือ "รู้ได้อย่างไรว่ามันดีจริง" — และคำตอบไม่ใช่ accuracy บน training set (ซึ่ง relu ได้ 100% ในหน้า 34 แต่นั่นคือข้อสอบที่โมเดลเคยเห็นเฉลยมาแล้ว).

อาจารย์เปิดหน้าด้วยการทำสี • Goal ไว้ชัดเจน: determine how well a model can be expected to perform on unseen examples — เป้าหมายคือคาดการณ์ผลบนข้อมูลที่โมเดลไม่เคยเห็น ไม่ใช่ข้อมูลที่ใช้เทรน. จากนั้นตั้งคำถาม • How to evaluate the model และให้สองแนวทาง:

แนวทางที่ 1 — แบ่งสามส่วน: • Training, Validation และ Test Set เช่น สุ่มแบ่ง 60-20-20 หรือ 70-15-15. แปลงเป็นตัวเลขจริงกับชุดข้อมูล 1,000 ตัวอย่าง:

หน้าที่ของแต่ละส่วนต่างกันคนละเรื่อง และนี่คือจุดที่สับสนบ่อย: training set ใช้ปรับ \(\theta\) (backprop ทำงานกับชุดนี้เท่านั้น); validation set ใช้ตามที่สไลด์เขียนว่า "Evaluate an array of different architectures (#hidden units, #layer, lambda….) on your validation set" — คือใช้เลือก hyperparameter ว่าจะเอากี่ layer กี่ node \(\lambda\) เท่าไร; test set ใช้รายงานผลครั้งเดียวตอนจบ ห้ามเอามาตัดสินใจอะไรทั้งสิ้น (ไม่งั้นมันก็กลายเป็น validation set อีกอัน).

คำเตือนที่สำคัญที่สุดของหน้า: "Make sure that all train/validation/test set comes from the same distribution to preventing data leakage during the testing process." — ทุกชุดต้องมาจากการแจกแจงเดียวกัน. ตัวอย่างที่ผิด: เทรนด้วยรูปถ่ายจากกล้องมืออาชีพ แต่ test ด้วยรูปจากมือถือ ⇒ ผลที่วัดได้ไม่สะท้อนความจริง. ส่วน data leakage คืออาการที่ข้อมูล test รั่วเข้าไปในขั้นตอนเทรน เช่น normalize ข้อมูลทั้งก้อนก่อนแบ่ง (ค่าเฉลี่ยที่ใช้ปนข้อมูล test ไปแล้ว) หรือมีตัวอย่างซ้ำอยู่ทั้งสองฝั่ง ⇒ คะแนน test สูงเกินจริง.

แนวทางที่ 2 — แบ่งสองส่วนแล้วทำ cross validation: • Training และ Test Set (เช่น สุ่ม 80-20 หรือ 70-30) แล้วทำ Cross Validation. สไลด์อธิบายวิธี k-fold ไว้ว่า "dividing the dataset into k subsets (folds). The model is trained on k-1 folds and validated on the remaining fold, with this process repeated k times".

เมื่อวัดผลแล้วไม่พอใจ หน้านี้บอกว่าต้องวินิจฉัยก่อนว่าเป็นโรคไหน แล้วจึงเลือกยา — ใช้ยาผิดโรคจะแย่ลง:

สังเกตว่ารายการทั้งสองฝั่งตรงข้ามกันเป๊ะ: bias สูงให้ เพิ่ม hidden/layer, variance สูงให้ ลด hidden/layer. นี่คือกับดักข้อสอบที่พบบ่อยที่สุดของหน้านี้ — ถ้าจำสลับกันก็ตอบผิดทั้งข้อ. วิธีจำ: bias สูง = โมเดลโง่เกินไป ต้องทำให้ฉลาดขึ้น; variance สูง = โมเดลท่องจำมากเกินไป ต้องทำให้มันจำน้อยลง. คำว่า "(later)" ที่กำกับ Dropout / Early stopping / Data Augmentation หมายถึงจะสอนในบทหลัง (Lesson 6) — ส่วน Regularization สอนในหน้าถัดไปของบทนี้เลย.

กราฟ "Diagnostic Bias vs Variance" ตรงกลางหน้าคือเครื่องมือวินิจฉัยที่ใช้จริง: แกนนอนคือ Training Time (จำนวนรอบ) เส้นสีแดง \(J_{\text{train}}\) ลดลงเรื่อยๆ ไม่หยุด ส่วนเส้นสีเขียว \(J_{cv}\) ลดลงช่วงแรกแล้วกลับเชิดขึ้น. ช่วงซ้ายสุด (ทั้งสองเส้นยังสูง) คือโซน High Bias; ช่วงขวาสุด (เส้นแดงต่ำ เส้นเขียวสูง ช่องว่างกว้าง) คือโซน High Variance; จุดที่ \(J_{cv}\) ต่ำสุดคือจุดที่ควรหยุด. นี่เชื่อมกับข้อความใต้ภาพพอดี: "A major challenge in training neural networks is how long to train them — long enough to learn the mapping, but not so long that it overfits the training data. Stop training at the point when performance on a validation set starts to degrade." ซึ่งก็คือนิยามของ early stopping นั่นเอง. ภาพ training history สองภาพด้านขวาแสดงอาการจริง: ภาพบน (High Bias) เส้น acc และ val_acc ต่ำใกล้กันทั้งคู่ราว 0.6–0.7; ภาพล่าง (High Variance) เส้น acc ไต่ขึ้นเกือบ 0.9 แต่ val_acc ค้างที่ ~0.7 และ val_loss เชิดขึ้นสวนทางกับ loss ที่ดิ่งลงเหลือ 0.2 — ช่องว่างระหว่างเส้นฝึกกับเส้น validation คือตัวชี้วัด overfitting ที่อ่านง่ายที่สุด.

7. Regularization: บีบ weight ให้เล็กเพื่อแก้ High Variance

หน้า 40 ระบุ "Regularization" เป็นหนึ่งในยาแก้ High Variance สามหน้าถัดไปคือคำอธิบายเต็มของยาตัวนั้น.

แนวคิดที่อาจารย์ทำสีไว้: • Keep all features (each contributes a bit to predict output) แต่ constrains or regularizes พารามิเตอร์ให้เป็นค่าเล็กๆ ("many cases towards zero but not zero").

ทำไมวิธีนี้ถึงแก้ overfitting ได้: ลองนึกถึงเครือข่ายที่ท่องจำข้อมูลฝึกได้เป๊ะ — มันต้องวาดเส้นแบ่งที่หยักไปมาอย่างรุนแรงเพื่อเลี้ยวหลบจุดแปลกๆ ทุกจุด และการจะหยักแรงได้ต้องมี weight ที่ใหญ่ (เพราะ \(z=\sum\theta x\) จะเปลี่ยนเร็วเมื่อ \(\theta\) ใหญ่). ดังนั้นการบีบ \(\theta\) ให้เล็กลงก็คือการบังคับให้เส้นแบ่ง "เรียบขึ้น" โดยอัตโนมัติ. ภาพ Circle Dataset สองภาพในสไลด์แสดงผลนี้ตรงๆ: ภาพซ้ายเส้นแบ่งบิดเป็นหยักเว้าแหว่งไล่ตามจุดข้อมูลรายจุด ส่วนภาพขวาเส้นแบ่งเป็นวงรีเรียบที่คลุมกลุ่มจุดสีแดงตรงกลางได้โดยไม่ไล่ตามจุดรบกวนแต่ละจุด — ข้อมูลชุดเดียวกัน ต่างกันแค่มีเทอม regularization หรือไม่.

"Keep all features" คือจุดต่างสำคัญ — ไม่ได้ทิ้ง feature ไหนเลย แค่ลดเสียงของทุก feature ลงพร้อมกัน

วิธีทำคือบวกเทอมโทษ (penalty) เข้าไปใน cost:

ผลรวมมีสามชั้นเพราะต้องไล่ให้ครบทุก weight: \(l\) = layer, \(i\) = node ปลายทางใน layer นั้น, \(j\) = node ต้นทาง. ส่วน \(\lambda\) (lambda) คือ hyperparameter ที่ควบคุมว่าจะบีบแรงแค่ไหน — \(\lambda=0\) คือไม่บีบเลย, \(\lambda\) ใหญ่คือบีบจน weight เกือบเป็นศูนย์หมด (underfit).

หน้านี้วาง L2 กับ L1 เทียบกันให้เห็นว่าต่างกันแค่จุดเดียว:

อาจารย์ทำสีไว้ว่า • L2 Regularization (หรือ Ridge) คือการเพิ่ม cost ที่แปรผันกับ square of the value of parameters ส่วน • L1 Regularization (หรือ Lasso) แปรผันกับ absolute v alue of parameters.

ตัวเลขในตารางบอกความต่างเชิงพฤติกรรม: L2 ลงโทษ weight ตัวใหญ่หนักกว่ามาก (\(\theta=3\) โดน 9 ส่วน \(\theta=0.5\) โดนแค่ 0.25 — ต่างกัน 36 เท่า ทั้งที่ค่าต่างกัน 6 เท่า) จึงเน้นกด weight ก้อนใหญ่ให้เล็กลงแต่ไม่ค่อยฆ่าให้เป็นศูนย์. ส่วน L1 ลงโทษเป็นสัดส่วนตรง (ต่างกัน 6 เท่าพอดี) ⇒ มีแรงกดคงที่แม้ weight เล็กมาก จึงมักดัน weight บางตัวให้เป็นศูนย์สนิท (เท่ากับคัด feature ทิ้ง).

คำเตือนตัวหนาใต้หน้า 42 ที่ออกสอบง่ายมาก: "Note that the regularization term should only be added to the cost function during training. Once the model is trained, you want to evaluate the model's performance using the unregularized performance measure." — เทอม regularization ใส่เฉพาะตอนเทรนเท่านั้น. เหตุผล: ค่า \(J_{\text{reg}}\) เป็นส่วนผสมของ "ทำนายผิดเท่าไร" กับ "weight ใหญ่เท่าไร" ⇒ ถ้าเอาไปรายงานผล ตัวเลขจะไม่ใช่ความผิดพลาดของการทำนายจริง และเทียบข้ามโมเดลที่ใช้ \(\lambda\) ต่างกันไม่ได้เลย.

ประโยคแรกของหน้าตอบคำถามที่ค้างจากหน้า 41 ว่า "ทำไมเน้น L2": "Unfortunately, Lasso may behave erratically when several features are strongly correlated and is not amenable to gradient descent, which means that we won't be able to solve it from scratch. Hence, we will focus on L2." — เหตุผลสองข้อคือ (1) L1 แกว่งไม่นิ่งเมื่อ feature สัมพันธ์กันมาก และ (2) L1 เข้ากับ gradient descent ไม่ได้. ข้อหลังมีเหตุผลทางคณิตศาสตร์ตรงไปตรงมา: อนุพันธ์ของ \(|\theta|\) ที่ \(\theta=0\) ไม่มีอยู่จริง (ความชันฝั่งซ้ายเป็น −1 ฝั่งขวาเป็น +1 ไม่เท่ากัน — เหมือนมุมหักของ ReLU ที่ 0) ส่วนอนุพันธ์ของ \(\theta^2\) คือ \(2\theta\) ซึ่งหาได้ทุกจุดรวมทั้งที่ 0. เมื่อจะเขียน backprop เองจากศูนย์จึงใช้ L2 ได้สะดวกกว่า.

สูตร gradient ที่รวม regularization แล้ว (สไลด์แยกเป็นสองกรณี):

คอลัมน์ \(j=0\) คือ bias — ไม่ถูกบีบ; คอลัมน์อื่นบวกเทอม \(\dfrac{\lambda}{m}\theta\) เข้าไปใน gradient

แล้วอัปเดตด้วยกฎเดิมทุกประการ \(\theta_{ij}^{[l]} := \theta_{ij}^{[l]} - \alpha\dfrac{\partial J(\theta)}{\partial\theta_{ij}^{[l]}}\) (สไลด์ไฮไลต์สีเหลืองไว้เพื่อย้ำว่าไม่มีอะไรเปลี่ยนในขั้นอัปเดต — สิ่งที่เปลี่ยนคือค่าของ gradient เท่านั้น).

หมายเหตุท้ายหน้า 43: "Note that some literature divides the cost function by 2 so that the gradient of regularization terms are resulted as above. We will use this equation and this trick in the workshop." — บางตำราเขียน cost เป็น \(\frac{1}{2m}\) และเทอม penalty เป็น \(\frac{\lambda}{2m}\sum\theta^2\) เพื่อให้เวลาหาอนุพันธ์ เลข 2 จากกำลังสอง (\(\frac{d}{d\theta}\theta^2 = 2\theta\)) ไปหักกับ 2 ที่ตัวส่วนพอดี ⇒ เหลือ \(\frac{\lambda}{m}\theta\) สวยงามตามสูตรข้างบน. สไลด์ระบุว่าจะใช้รูปนี้ต่อใน workshop จึงควรจำรูปนี้.

7A. Best Practice, Parameter vs Hyperparameter และ Tuning Guideline

สไลด์ให้สูตรการทำงานสามข้อ: (1) "Starting with relatively few layers and/or parameters" — เริ่มจากเล็กก่อน; (2) "Gradually increase the size of the layers (increase the number of neurons) or add new layers until you see diminishing returns with regards to validation loss" — ค่อยๆ ขยายจนกว่าจะเริ่มได้ผลตอบแทนลดน้อยถอยลง โดยดูจาก validation loss ไม่ใช่ training loss; (3) "Use techniques to overcome overfitting" — เมื่อขยายจนเริ่ม overfit ก็ใส่ยาจากรายการหน้า 40.

กราฟสามภาพใต้หน้าคือสามสถานะที่ต้องแยกให้ออกจากเส้น 4 เส้น (loss, accuracy, val_loss, val_accuracy): ภาพ High Bias — เส้น accuracy กับ val_accuracy พันกันอยู่แถว 0.6–0.7 และ loss ลงช้าๆ ค้างที่ ~0.55 แปลว่าโมเดลไม่เก่งพอแม้แต่กับข้อมูลที่เคยเห็น; ภาพ High Variance — accuracy ไต่ถึง ~0.93 แต่ val_accuracy ค้างที่ ~0.73 และ val_loss เชิดขึ้นสวนทาง loss ที่ลงไปถึง ~0.2 แปลว่าท่องจำข้อมูลฝึกแต่ใช้กับของใหม่ไม่ได้; ภาพ Low Bias and Low Variance (Right Model) — ทั้ง accuracy และ val_accuracy วิ่งไปชนเพดานเกือบ 1.0 พร้อมกัน และ loss กับ val_loss ก็ลงมาต่ำใกล้กันทั้งคู่ภายในราว 4 epoch. ตัวชี้วัดที่ต้องดูจึงไม่ใช่เส้นใดเส้นหนึ่ง แต่คือ "ช่องว่างระหว่างเส้นฝึกกับเส้น validation" ควบคู่กับ "ระดับความสูงของทั้งคู่".

นิยามสองคำที่สับสนกันบ่อยที่สุดในวิชานี้: Parameter คือ \(\theta\) ซึ่ง "initialized randomly" แล้วโมเดลเรียนรู้เองผ่าน backprop + gradient descent; Hyper Parameter คือ "a parameter that control \(\theta\)" — ตัวที่เราตั้งเองก่อนเทรน และเป็นตัวกำหนดว่า \(\theta\) จะถูกเรียนอย่างไร.

รายการ hyperparameter ที่สไลด์ให้ โดยสองตัวแรกทำสีแดงไว้: • Learning rate 𝛼, #layer, # hidden units, lambda, keep_prob, activation functions, #iterations. สังเกตว่าทุกตัวในรายการนี้ไม่มีตัวไหนถูกอัปเดตโดย gradient descent เลย — นั่นคือเส้นแบ่งที่ชัดที่สุดระหว่างสองคำ. (\(\lambda\) คือค่าความแรงของ regularization จาก §7; keep_prob เป็นของ Dropout ซึ่งจะสอนใน Lesson 6.)

parameter = สิ่งที่โมเดลเรียนเอง; hyperparameter = ปุ่มที่เราหมุนเอง แล้วเลือกค่าที่ดีที่สุดด้วย validation set

หน้านี้ให้ตัวเลขที่ใช้ตอบข้อสอบได้ตรงๆ สามกลุ่ม:

1. • Number of Layers — "Typically, 1-5, 1 hidden layer is by default and 2 layers might be good enough" และ "larger and more layers are capable of identifying more subtle patterns and complex decision boundaries". ตัวเลขที่ต้องจำ: 1–5 ชั้น, ค่าเริ่มต้นคือ 1 ชั้น, 2 ชั้นมักพอแล้ว.

2. • Number of Hidden Units — สไลด์ให้การชั่งน้ำหนักสองด้านและข้อปฏิบัติที่เปลี่ยนไป:

ข้อ "พีระมิดถูกเลิกใช้แล้ว" เป็นจุดที่อาจารย์เขียนยาวที่สุดในหน้า จึงมีโอกาสออกสอบสูง — และเหตุผลที่ให้ไว้ไม่ใช่แค่ "ผลเท่ากัน" แต่คือมี hyperparameter ให้จูนแค่ตัวเดียวแทนที่จะเป็นตัวหนึ่งต่อชั้น. ลองคิดเป็นตัวเลข: เครือข่าย 3 hidden layer แบบพีระมิดต้องเลือก \((n_1, n_2, n_3)\) สามตัว ถ้าแต่ละตัวมี 10 ทางเลือกก็ต้องลอง \(10^3 = 1000\) แบบ; แต่ถ้าใช้จำนวนเท่ากันทุกชั้นเหลือ 10 แบบ — ประหยัดกว่าร้อยเท่า.

3. • Learning rate 𝜶 — "By plotting the cost function or automatic debugging, however the best is parameter tuning (later class)" — วิธีพื้นฐานคือพล็อตกราฟ cost ดูด้วยตา (\(\alpha\) ใหญ่ไป cost จะแกว่งหรือพุ่งขึ้น; \(\alpha\) เล็กไป cost จะลงช้ามาก) ส่วนวิธีที่ดีที่สุดคือ hyperparameter tuning อย่างเป็นระบบ ซึ่งสไลด์บอกว่าจะสอนในคาบหลัง (Lesson 6).

8. Binary Classification Exercise: ฝึกเขียนสูตรทั่วไปด้วยตัวเอง

สองหน้าสุดท้ายก่อน references คือแบบฝึกหัดที่อาจารย์ทิ้งไว้ให้เขียนเอง — ไม่มีตัวเลข \(\theta\) ให้ เพราะเป้าหมายคือฝึกเขียนสูตร ไม่ใช่กดเครื่องคิดเลข.

โจทย์: shallow neural network ที่รับ \(x_1, x_2\) (+ \(x_0\)) → hidden 10 node → output 1 node ที่ให้คำตอบเป็น \(\{0,1\}\) บนชุดข้อมูล Spiral (เกลียวสองสีที่แยกกันด้วยเส้นตรงไม่ได้ — จึงต้องใช้ hidden layer). เฉลย Forward Computation:

หน้า 48 ถามส่วน backward ของเครือข่ายเดียวกัน. ประเด็นทั้งหมดของแบบฝึกหัดนี้คือ: สูตรไม่เปลี่ยนเลยแม้ hidden จะมี 10 node แทน 2 node — เปลี่ยนแค่ช่วงของ \(j\).

ภาคผนวก: Slide ทั้งหมดใน Lecture3.pdf (49 หน้า) — เช็คว่าอ่านครบ

หมายเหตุ: เนื้อหาทั้ง 49 หน้านี้เหมือนกับ Lecture2.pdf หน้า 50-98 เป๊ะทุกตัวอักษร (ดู Lesson 2 หมายเหตุต้นบท) ภาคผนวกนี้จึงครอบคลุมทั้ง Lecture2.pdf หน้า 50-98 ไปในตัว.

สงสัยตรงไหน ถามได้เลยในแชท — ผมเป็นผู้สอนของคุณ ถามซ้ำได้ ถามลึกได้ ไม่ต้องเกรงใจ.