Lecture1.pdf · 2603520 Deep Learning

Machine Learning Foundations: การคำนวณที่ Deep Learning ทุกบทใช้ต่อ

Lecture นี้ปูพื้น ML ก่อนเข้า Deep Learning จริง — แนวคิด cost function, gradient descent, sigmoid, softmax, regularization ที่เรียนในบทนี้จะถูกใช้ซ้ำ "เหมือนเดิมทุกตัวอักษร" ในทุก Lecture ถัดไป (แค่เปลี่ยนจาก 1 node เป็นหลาย node/หลาย layer). ถ้าคำนวณมือได้ในบทนี้ Lesson 2–6 ก็คือแค่ต่อยอดสัญกรณ์ ไม่ใช่ต่อยอดหลักการ.

บทเรียนนี้เดินตามสไลด์ ทีละหน้า ตั้งแต่หน้า 1 ถึงหน้า 60 ไม่ข้ามหน้าไหน เพราะข้อสอบของวิชานี้ออกจากสไลด์โดยตรง และประโยคที่อาจารย์ ทำสี ไว้บนสไลด์คือประโยคที่มีโอกาสกลายเป็นตัวเลือกในข้อสอบสูงที่สุด. ทุกครั้งที่เห็นข้อความไฮไลต์สีเหลืองแบบนี้ Introduction: Deep Learning แปลว่าเป็นข้อความที่ยกมาจากสไลด์ตรงตัว พร้อมเลขหน้ากำกับ.

0. ปฐมนิเทศ: วิชานี้สอนอะไร และสอบอย่างไร

สไลด์สามหน้าแรกหลังปกคือข้อมูลของวิชา ซึ่งดูเหมือนไม่ใช่เนื้อหา แต่บอกสองเรื่องที่มีผลกับการอ่านหนังสือสอบโดยตรง: ขอบเขตของ midterm และ พื้นฐานที่อาจารย์ถือว่าคุณมีแล้ว.

ผู้สอนคือ Asst. Prof. Dr. Suronapee Phoomvuthisarn (Aj. Peng) อีเมล suronapee@cbs.chula.ac.th. สไลด์หน้านี้แบ่งข้อมูลเป็นสองหัวข้อย่อยที่อาจารย์ทำสีไว้คือ Education (ปริญญาตรีวิศวกรรมคอมพิวเตอร์ จุฬาฯ, ปริญญาโท Information Science จาก University of Pittsburgh, ปริญญาเอก Computer Science and Engineering จาก University of New South Wales) และ Instructor Experience (ลิงก์ไปยัง Curriculum Vitae). ประเด็นที่ใช้ได้จริงคือ สายงานของอาจารย์เป็น software engineering + AI ประยุกต์ ดังนั้นตัวอย่างในคอร์สจะโน้มไปทางระบบจริง (RAG, multi-agent, medical imaging) มากกว่าคณิตศาสตร์เชิงทฤษฎีล้วน.

หน้า 3 วางโครงคอร์สไว้ 5 ส่วน: Part 1–2 Deep Learning Fundamentals (Class 2–6) คือ Neural Network, Deep Neural Network, Parameter Tuning — ตรงกับ Lesson 1–6 ของชุดบทเรียนนี้; Part 3 (Class 7–9) Computer Vision ได้แก่ CNN, Transfer Learning, Object Detection; Part 4 (Class 10–12) Sequence Data ได้แก่ Sequence Modelling, Transformer, LLM, RAG & Prompt Engineering; Part 5 (Class 13–15) Generative Deep Learning ได้แก่ VAE, GAN, Diffusion Model, Multimodal และหัวข้อขั้นสูงอย่าง Agentic AI. Learning outcome ที่ระบุไว้คือ "ability to apply deep learning in subject-domain projects" — คือ ประยุกต์ ไม่ใช่พิสูจน์ทฤษฎี.

หน้า 4 คือเกณฑ์คะแนนซึ่งกำหนดขอบเขตการสอบชัดเจน: Homework 20%, Assignment 10%, Midterm 30% ครอบคลุม Week 1–6, Final 40% ครอบคลุม Week 7–15 และมีหมายเหตุขีดเส้นใต้ว่า "Note that Week7 will be taught before midterm" — แปลว่าเนื้อหาสัปดาห์ที่ 7 ถูกสอนก่อนสอบกลางภาค แต่ตามน้ำหนักคะแนนแล้วมันนับอยู่ฝั่ง final. เมื่อ Lecture 1–6 = Week 1–6 พอดี บทเรียนชุดนี้ทั้ง 6 บทจึงเท่ากับ "ขอบเขต midterm" เต็ม ๆ. หน้าเดียวกันยังระบุ pre-requisite ไว้สองข้อคือ college level mathematical background และ basic Python programming — นี่คือเหตุผลที่บทเรียนนี้แทรกกล่อง "ต้องรู้ก่อน" สีม่วงทุกครั้งที่จะใช้คณิตศาสตร์ตัวใหม่ เพราะถ้าพื้นคณิตหายไป สูตรทุกสูตรจะกลายเป็นสิ่งที่ต้องท่องแทนที่จะเข้าใจ.

0A. AI → Machine Learning → Deep Learning: นิยามที่ต้องท่องได้

ก่อนจะคำนวณอะไรได้ ต้องแยกให้ออกก่อนว่าคำสามคำนี้ซ้อนกันอยู่อย่างไร เพราะข้อสอบปรนัยชอบถามแบบ "ข้อใดคือความสัมพันธ์ที่ถูกต้อง". สไลด์หน้า 6 เปิดด้วยประโยคของ Andrew Ng ว่า "AI is a new electricity" — เปรียบ AI เป็นสาธารณูปโภคพื้นฐานแบบไฟฟ้า คือไม่ใช่สินค้าชิ้นเดียวแต่เป็นสิ่งที่แทรกอยู่ในทุกอุตสาหกรรม พร้อมยกตัวอย่างระบบจริงคือ OpenAI Operator ที่จองทัวร์บนเว็บ TripAdvisor ให้เองได้.

นิยามที่ต้องท่องได้คำต่อคำคือของ A. Samuel (1952): Machine Learning (ML) is "the field of study that gives computers the ability to learn without being explicitly programmed". แปลทีละชิ้น: the field of study = ML เป็น "สาขาวิชา" ไม่ใช่โปรแกรมหรือเครื่องมือชิ้นหนึ่ง (ข้อสอบชอบสลับเป็น "a computer program" หรือ "a type of hardware"); ability to learn = ความสามารถที่จะเรียนรู้ ซึ่งวัดจากการที่ผลลัพธ์ดีขึ้นเมื่อได้ข้อมูลมากขึ้น; without being explicitly programmed = โดยไม่ต้องเขียนกฎให้ตรง ๆ ทีละข้อ.

ส่วนที่ทำให้เห็นภาพที่สุดคือสองแผนภาพล่างของสไลด์ ซึ่งสลับตำแหน่งของ "Rule" กับ "Answer" กัน: ฝั่ง Symbolic AI เดินจาก Rule → Programming → Answer; ฝั่ง Machine Learning เดินจาก Answer → Programming → Rule. ลองแทนด้วยตัวอย่าง Google Suggest บนสไลด์: แบบ Symbolic AI โปรแกรมเมอร์ต้องเขียนกฎเองว่า "ถ้าผู้ใช้พิมพ์ 'สมาคมประ' ให้เดาว่า…" ซึ่งต้องเขียนเป็นล้านกฎและตกยุคทันทีที่คำค้นใหม่เกิดขึ้น; แบบ Machine Learning เราป้อน คำตอบ (ประวัติการค้นจริงของผู้ใช้หลายพันล้านครั้ง) ให้เครื่อง แล้วเครื่องสรุป กฎ ออกมาเอง. นี่คือสาระของคำว่า "ไม่ต้อง explicitly programmed" — เราไม่ได้เลิกเขียนโปรแกรม แต่เปลี่ยนสิ่งที่ป้อนเข้าไปจากกฎเป็นคำตอบ. ภาพวงกลมซ้อนมุมขวาย้ำว่า Machine Learning เป็น วงใน ของ Artificial Intelligence: AI = ซอฟต์แวร์ที่แก้ปัญหาได้เอง, ML = อัลกอริทึมที่เรียนจากข้อมูล ซึ่งเป็นวิธีหนึ่งของ AI เท่านั้น.

ประโยคหลักของหน้านี้คือ "Deep Learning (DL) is a specific subfield of Machine Learning" และเหตุผลสองข้อที่ DL เอาชนะ ML ดั้งเดิมได้ก็คือสองวลีที่ถูกทำสี: complex network และ automatically learning features from data. แผนภาพวงซ้อนด้านขวาไล่ลำดับได้ว่า Machine Learning ⊃ {"Traditional" ML = linear/logistic regression, decision trees, random forests, SVM} ∪ {Representation Learning ⊃ ANN / Deep Learning}. อ่านว่า: linear regression ที่เรากำลังจะเรียนในหัวข้อ 2 อยู่ในกล่อง "traditional" ส่วน deep learning อยู่ในกล่อง representation learning ซึ่งซ้อนอยู่อีกชั้นหนึ่ง ทั้งคู่เป็น ML เหมือนกัน. ความต่างไม่ใช่ "DL ฉลาดกว่า" แต่คือ traditional ML ต้องให้มนุษย์บอกว่าจะใช้ feature อะไร (เช่นบอกว่า "ดูขนาดบ้านกับจำนวนห้องนอน") ส่วน DL หา feature ที่ควรใช้เองจากข้อมูลดิบ.

หน้านี้ให้นิยามของสิ่งที่ Lesson 2 จะขยายเต็ม ๆ: Deep Learning สร้างบนแนวคิด Artificial Neural Networks (ANN). โดย ANN คือ mathematical model สำหรับการคำนวณ ประกอบด้วย stacked layers ที่แต่ละชั้นบรรจุ nodes ซึ่งได้แรงบันดาลใจจาก neural units ใน biological brain. คำว่า "mathematical model" สำคัญมากและเป็นกับดักข้อสอบข้อแรก ๆ: ANN ไม่ใช่ การจำลองสมองจริง มันแค่ยืมรูปทรงมา — เซลล์ประสาทจริงรับสัญญาณเข้าทาง dendrite แล้วส่งออกทาง axon ส่วน node เทียมรับตัวเลข \(x_1, x_2\) เข้ามา คูณด้วยน้ำหนัก บวกกัน แล้วปล่อยตัวเลขเดียวออกไปเป็น \(h_\theta(x)\). ทั้งหมดที่เกิดขึ้นในวงกลมสีฟ้าวงนั้นคือ \(h_\theta(x)=\theta_0+\theta_1x_1+\theta_2x_2\) แล้วส่งผ่านฟังก์ชันบีบค่า ซึ่งก็คือ logistic regression ในหัวข้อ 5 ของบทนี้เป๊ะ ๆ. นี่คือเหตุผลที่บทที่ 1 ต้องแน่นก่อน: 1 node = 1 logistic regression.

คำว่า "Deep" ในชื่อวิชาถูกนิยามตรงนี้: Neural networks that have multiple hidden layers (can be infinite!!) และจุดเน้นคือ "learning successive layers of processing units to incrementally grasp meaningful representations from data" — เรียนรู้ทีละชั้นเพื่อ ค่อย ๆ ได้ตัวแทนข้อมูลที่มีความหมายขึ้น. อ่านแผนภาพตามชื่อชั้นที่สไลด์กำกับไว้: \(x_1, x_2\) เข้า Layer 1 → Layer 2 → … → Layer L−2 → Layer L−1 → Layer L ที่มี node เดียวให้ค่า \(h_\theta(x)\) ออกมา โดยชั้นแรกสุดเรียก Input ชั้นสุดท้ายเรียก Output และทุกชั้นตรงกลางเรียก Hidden. คำว่า Fully Connected หมายถึงทุก node ในชั้นหนึ่งต่อกับทุก node ในชั้นถัดไปครบทุกเส้น และ Feed-Forward หมายถึงสัญญาณไหลไปข้างหน้าทางเดียว ไม่วนย้อนกลับ. กล่องล่างที่เขียนว่า Hidden Layers (black box) คือที่มาของข้อจำกัดเรื่องการตีความในหน้า 19: เรารู้ว่า input อะไรเข้าและ output อะไรออก แต่บอกไม่ได้ง่าย ๆ ว่าชั้นกลางคิดอะไรอยู่.

ปีที่อาจารย์ทำสีไว้มีห้าปี และแต่ละปีมีเหตุการณ์เจาะจงที่ควรจำคู่กัน: 1943 Walter Pitts และ Warren McCulloch สร้างแบบจำลองคอมพิวเตอร์จากโครงข่ายประสาทของสมองมนุษย์ (จุดกำเนิดของ "artificial neuron"); 1989, Yann LeCun รวมแนวคิด convolutional neural network เข้ากับ backpropagation จนอ่านตัวเลขลายมือได้สำเร็จที่ Bell Labs — นับเป็น "the first successful practical application of neural nets"; 2010 deep learning เริ่มพุ่ง; 2014 GANs; 2017 Transformer. บทเรียนที่ใช้สอบได้คือ ช่องว่าง 46 ปีระหว่าง 1943 กับ 1989 และอีก 21 ปีจนถึง 2010: ทฤษฎีมีมานานแล้ว สิ่งที่มาทีหลังคือข้อมูลกับพลังประมวลผล (หน้า 14). กราฟจุดด้านขวาเสริมด้วยตัวเลขจริงของขนาดโมเดล — GPT รุ่นแรกมีราว 0.117 พันล้านพารามิเตอร์ ขณะที่ PaLM ที่จุดปี 2022 มี 540 พันล้าน คือต่างกันราว 4,600 เท่าภายในไม่กี่ปี ซึ่งเป็นไปได้เพราะหลัง Transformer (2017) การเพิ่มขนาดโมเดลให้ผลตอบแทนคุ้มค่าต่อเนื่อง. ตัวเลขชุดนี้ก็คือ "ขนาดของ \(\theta\)" ที่เรากำลังจะเริ่มนับจาก 2 ตัวในหัวข้อ 2.

1. ทำไม Deep Learning ถึง "ทรงพลัง" — และข้อจำกัดที่ยังแก้ไม่ได้

สไลด์หน้า 12–14 ตอบคำถามว่าทำไม DL ถึงชนะ และหน้า 19 ตอบว่าราคาที่ต้องจ่ายคืออะไร. อ่านสองฝั่งนี้คู่กันเสมอ เพราะข้อสอบมักถามแบบ "ข้อใดไม่ใช่ข้อดี/ข้อจำกัดของ DL".

เหตุผลข้อแรกคือ Scale for complex tasks ซึ่งแตกเป็นสองกรณี. กรณีแรก "tasks that need complex non-linear decision boundary (e.g., classification)" — ถ้าเส้นแบ่งระหว่างสองคลาสไม่ใช่เส้นตรง โมเดลเชิงเส้นตัวเดียวจะทำไม่ได้ ต้องซ้อนหลายชั้นเพื่อดัดเส้นให้โค้ง (เราจะเห็นตัวอย่างเส้นโค้งจริงในหน้า 38 และ 43). กรณีที่สอง "tasks that involve data with many input features (e.g., applications in computer vision or NLP)" — ลองนับจริง: ภาพใบหน้าขาวดำขนาด 100×100 พิกเซล มี \(100 \times 100 = 10{,}000\) ตัวเลขต่อภาพ ถ้าเป็นภาพสี RGB จะเป็น \(10{,}000 \times 3 = 30{,}000\) feature. โมเดลอย่าง linear regression ที่มี \(\theta\) ตัวละ feature จะต้องให้มนุษย์ตัดสินใจว่าจะย่อ 30,000 ตัวเลขนี้เป็น feature อะไรก่อน ขณะที่โครงข่ายลึกรับเข้าไปดิบ ๆ แล้วให้ชั้นต้น ๆ หา "ขอบ" ชั้นถัดไปหา "ส่วนของใบหน้า" ชั้นลึกสุดจึงตอบว่าเป็น Lee, Chris หรือ Joe ตามที่สไลด์กำกับชื่อ output ไว้.

เหตุผลข้อที่สองคือ Automate feature engineering (i.e., representation learning): "learn features from the input data, without the need for human guidance" และ "this is one of the reasons why DL can handle unstructured data very well". สองเส้นทางที่สไลด์เทียบกันใช้โจทย์เดียวกันคือดูภาพรถแล้วตอบ Car / Not Car. เส้นทาง Machine Learning มีสามกล่อง — Input → Feature extraction ที่มีคนนั่งทำ → Classification; เส้นทาง Deep Learning เหลือสองกล่อง — Input → Feature extraction + Classification รวมอยู่ในโครงข่ายเดียว. ความหมายเชิงปฏิบัติ: ในแบบแรกถ้าใครออกแบบ feature ว่า "นับจำนวนวงกลม (ล้อ)" แล้วเจอรถที่ถ่ายด้านหน้าซึ่งมองไม่เห็นล้อ โมเดลก็พัง และต้องให้คนกลับไปออกแบบ feature ใหม่; ในแบบที่สอง การเลือก feature กลายเป็นส่วนหนึ่งของค่า \(\theta\) ที่ถูกฝึกไปพร้อมกัน จึงปรับตัวเองได้จากข้อมูล. คำว่า unstructured data หมายถึงข้อมูลที่ไม่ได้อยู่ในตารางแถว-คอลัมน์ เช่น ภาพ เสียง ข้อความ — เป็นข้อมูลที่ "ไม่มีคอลัมน์สำเร็จรูปให้หยิบ" จึงได้ประโยชน์จากการหา feature อัตโนมัติมากที่สุด.

หน้านี้ตอบคำถามว่า "ถ้าทฤษฎีมีตั้งแต่ 1943 ทำไมเพิ่งดังปี 2010" ด้วยสองเหตุผล: Hugh quantity of data available (สไลด์สะกดว่า Hugh ซึ่งน่าจะหมายถึง huge) เพราะ "data usually can be directly accessed and collected by computers" และ Processing Capabilities จาก "increase in computing power such as GPUs". กราฟของ Andrew Ng ด้านขวาคือหัวใจ: แกนนอนคือจำนวนตัวอย่างฝึก แกนตั้งคือ performance. เส้นล่างสุด (traditional learning algorithms) ไต่ขึ้นตอนแรกแล้ว แบนราบ — ข้อมูลเพิ่มอีกก็ไม่ดีขึ้น เพราะความจุของโมเดลตันแล้ว; เส้น small → medium → large neural network ยัง ไต่ขึ้นเรื่อย ๆ และยิ่งโครงข่ายใหญ่ยิ่งได้ประโยชน์จากข้อมูลมาก. ข้อสรุปที่ใช้สอบได้: โครงข่ายใหญ่ ไม่ได้ดีกว่าเสมอ — ที่ข้อมูลน้อย ๆ ด้านซ้ายของกราฟ เส้นทั้งสี่แทบทับกัน ข้อได้เปรียบจะโผล่ก็ต่อเมื่อข้อมูลมากพอ. นี่คือเหตุผลเดียวกับที่หน้า 58 จะบอกว่า "เพิ่มข้อมูลช่วย high variance".

หน้า 15 รวบรวม Successful Applications ไว้ 20 งานจากบทความ mygreatlearning เช่น self-driving cars, visual recognition, fraud detection, natural language processing, automatic machine translation, colourisation of black and white images, photo descriptions ไปจนถึง deep dreaming — ประเด็นคือความกว้างของงาน ไม่ใช่รายชื่อที่ต้องท่อง. หน้า 16 และหน้า 17 เป็นผลงานวิจัยของอาจารย์เองซึ่งบอกใบ้ว่าหัวข้อปลายเทอมหน้าตาอย่างไร: ฝั่ง Computer Vision มี GANs in Healthcare (Singkorapoom & Phoomvuthisarn, 2023 — ศึกษาความทนทานของ pre-trained model ต่อการโจมตีแบบ poisoning ด้วยภาพเอกซเรย์ปอดที่ GAN สังเคราะห์ขึ้นให้ดูเหมือน Pneumonia/Normal) และ Virtual Try-on using Diffusion (Kiattithapanayong & Phoomvuthisarn, 2025 — เทียบผลลองเสื้อเสมือนระหว่าง LADI-VITON, VITON-HD, HR-VITON กับวิธีที่เสนอ); ฝั่ง NLP มี LLM tutor (RAG) ที่ตอบคำถามเชิงภาพว่า "What does the Transformer diagram show?" พร้อมแสดงเวลาในการค้นคืน 1.82 วินาทีและคะแนนความคล้ายของแหล่งอ้างอิง 0.5127 และ Multi-Agent Fact Verification for E-Commerce Q/A ที่ตัดสินคำตอบใน AnswerFact ว่า Supported ด้วยคะแนนรวม 1.00. ทั้งสี่งานนี้ใช้เทคนิคจาก Part 3–5 ของคอร์ส (CNN, GAN, Diffusion, Transformer, RAG) ซึ่งทุกตัวยังเรียนด้วย gradient descent + cost function ชุดเดียวกับบทนี้.

เครื่องมือนี้คือห้องทดลองที่เล่นได้จริงและตรงกับทุกคำที่บทเรียนนี้ใช้: ค่าบนหน้าจอในสไลด์คือ learning rate 0.03 (คือ \(\alpha\) ในหัวข้อ 3), activation Tanh (Lesson 2), regularization None และ regularization rate 0 (คือ \(\lambda\) ในหัวข้อ 11), hidden layers 3 ชั้นขนาด 4-4-1 node และผลลัพธ์คือ training loss 0.000 กับ test loss 0.002 หลังผ่านไป 1,013 epoch. ชุดข้อมูลที่เลือกเป็นแบบสี่ช่องสลับสี ซึ่งเส้นตรงเส้นเดียว แบ่งไม่ได้ — ต้องมี hidden layer ถึงจะได้เส้นแบ่งรูปกากบาทแบบนั้น จึงเป็นภาพสาธิตของประโยค "complex non-linear decision boundary" ในหน้า 12 โดยตรง. ลองปรับ learning rate เป็น 3 แล้วดู loss กระโดดขึ้น จะเห็นปรากฏการณ์เดียวกับตัวอย่างคำนวณ \(\alpha\) ใหญ่เกินไปในหัวข้อ 3.

ข้อจำกัดสามข้อที่ต้องตอบได้: (1) Deep learning is data hungry — "works better for large sets of data for training" และ "require large amount of computational resources" คือข้อได้เปรียบในหน้า 14 พลิกกลับด้าน ถ้ามีข้อมูลไม่กี่ร้อยแถว โมเดลเล็กแบบ logistic regression มักชนะ; (2) Given good predictions, but not easily interpretable — "black box's nature of Deep Learning might cause problem in domains like financial trades or medical diagnosis, in which human users might like to understand how a given system made a given decision" คือทำนายแม่นแต่บอกเหตุผลไม่ได้ ซึ่งเป็นปัญหาในงานที่ต้องอธิบายให้ลูกค้าหรือแพทย์ฟัง; (3) No common sense (Same as ML) — "little flexibility to extrapolate outside of the strict parameters it learned and knows". ตัวอย่างในสไลด์เล่าเรื่องนี้ชัด: เทรนด้วยภาพสุนัขสามภาพติดป้าย Dog แล้วพอ inference ป้อนภาพ แมว เข้าไป โมเดลก็ยังตอบว่า "Dog?!" เพราะมันไม่เคยเห็นคลาสอื่นและไม่มีสามัญสำนึกว่าสิ่งที่เห็นไม่ใช่สุนัข. กับดักข้อสอบคือสับสนระหว่าง "no common sense" (เดาเลยขอบเขตข้อมูลที่เคยเห็นไม่ได้) กับ "overfitting" (จำข้อมูลฝึกมากไปจนใช้กับข้อมูลใหม่ไม่ได้ — คนละเรื่อง ดูหัวข้อ 10).

1A. เครื่องเรียนรู้ได้อย่างไร: ข้อมูล → โมเดล → คำทำนาย

ถึงตรงนี้เรารู้แล้วว่า ML คือการให้เครื่องสรุปกฎจากคำตอบ แต่ "สรุปกฎ" เกิดขึ้นจริงอย่างไร? สไลด์หน้า 20–23 วางกระบวนการทั้งหมดไว้เป็นสามขั้นตอนซึ่งเป็นโครงของหัวข้อ 2 ถึง 3 ทั้งดุ้น. หน้า 20 ทวนนิยามของ Samuel ซ้ำอีกรอบ (เหมือนหน้า 7 ทุกตัวอักษร) แล้วหน้า 21 จึงลงรายละเอียดว่าการเรียนรู้แปลว่าอะไร.

Machine learning ทำให้เรา identify patterns ในข้อมูลได้โดยการสร้างโมเดลแล้วใช้โมเดลนั้นทำนาย และคำว่า "เรียนรู้" ถูกแตกเป็นสองจังหวะคือ learn from data เพื่อสร้างโมเดล แล้วจึงใช้โมเดลนั้น make predictions กับข้อมูลใหม่. แผนภาพในสไลด์จึงมีสามกล่องเรียงกัน: Training Data ป้อนลงมาที่กล่อง Model (h) และเมื่อมี Input เข้ามาก็ได้ Meaningful Output ออกไป. สังเกตว่า Training Data เข้าทางบนของกล่อง ส่วน Input เข้าทางซ้าย — สองเส้นนี้คนละหน้าที่กัน: training data ใช้ ครั้งเดียวตอนสร้าง \(h\) ส่วน input คือข้อมูลใหม่ที่เอามาถามโมเดลหลังสร้างเสร็จ. ตัวอย่างที่ใช้ต่อทั้งบทคือ Predicting Housing Price ซึ่งกราฟในสไลด์ลากเส้นตรงหลายเส้นผ่านกลุ่มจุดเดียวกัน — โดยจุดข้อมูลบอกว่าบ้านที่ราคา $70,000 กับ $160,000 ต่างกันที่ขนาด และคำถามคือ "เส้นไหนถูกที่สุด". คำว่า "ถูกที่สุด" นี่แหละคือสิ่งที่ต้องนิยามด้วยตัวเลข และตัวเลขนั้นคือ cost function ในหัวข้อ 3.

หน้านี้แนะนำสัญกรณ์อีกชุดที่จะเจอตอนเขียนโค้ด Keras ใน Lesson 2: Linear Equation \(y = wx + b\) โดย \(w\) คือ weight (เท่ากับ \(\theta_1\)) และ \(b\) คือ bias (เท่ากับ \(\theta_0\)) — คนละชื่อ สิ่งเดียวกัน. ตัวเลขที่พิมพ์ติดอยู่บนกราฟคือสถานะตอนเริ่มต้นจริง ๆ ของการฝึก: \(w = 0.217,\ b = 0.0433,\ \text{error} = 251.4894\) ที่ \(\text{iter} = 0\). อ่านได้ว่าเส้นเริ่มต้นเกือบแบนราบ (ความชัน 0.217) ทั้งที่กลุ่มจุดจริงลาดลงจากซ้ายบนไปขวาล่าง จึงพลาดไปมาก error จึงสูงถึง 251.49. ตัวเลข error ตัวนี้แหละคือ \(J(\theta)\) และงานที่เหลือทั้งบทคือ "ทำอย่างไรให้ 251.49 ลดลง".

ภาพสี่กราฟบนสไลด์คือเรื่องเดียวกันเล่าด้วยตัวเลขจริงตั้งแต่ From 0-1-100 iterations: รอบที่ 0 ได้ \(w=0.217,\ b=0.0433,\ \text{error}=251.4894\); รอบที่ 1 ได้ \(w=-1.0868,\ b=0.2112,\ \text{error}=125.5395\); พอถึงรอบที่ 100 ได้ \(w=-1.8056,\ b=5.3219,\ \text{error}=77.5002\). ลองอ่านเป็นเรื่องเล่า: ความชันถูกพลิกจากบวกเป็นลบตั้งแต่รอบแรก (เพราะข้อมูลลาดลง) และ error หล่นครึ่งหนึ่งทันที (251 → 126) จากนั้นการปรับก็ค่อย ๆ ละเอียดขึ้นและ error ลดช้าลง (126 → 77.5 ใช้ไปอีก 99 รอบ) — นี่คือพฤติกรรมมาตรฐานของ gradient descent ที่เราจะคำนวณมือในหัวข้อ 3 คือ "ก้าวใหญ่ตอนไกล ก้าวเล็กตอนใกล้".

ส่วนที่ต้องท่องคือสามขั้นตอนที่อาจารย์ทำสีไว้ภายใต้หัวข้อ Steps to get the model:

1. 1. Model Representation (if any) — เลือก "Mathematical model + Parameters" คือกำหนดรูปสูตรและบอกว่ามีพารามิเตอร์กี่ตัว (หัวข้อ 2 สำหรับ regression, หัวข้อ 5 สำหรับ classification)
2. Define Cost Function — "define feedback signal used for learning" คือสร้างตัวเลขที่บอกว่าตอนนี้ผิดแค่ไหน เพื่อใช้เป็นสัญญาณย้อนกลับ (หัวข้อ 3.1 และ 6)
3. 3. Parameter Learning — "determine how learning proceeds" คือเลือกวิธีขยับพารามิเตอร์ให้ cost ลดลง ซึ่งในวิชานี้คือ gradient descent (หัวข้อ 3.2)

คำว่า parametric model ในชื่อสไลด์หมายถึงโมเดลที่มีจำนวนพารามิเตอร์คงที่ ไม่โตตามจำนวนข้อมูล — linear regression, logistic regression และ neural network เป็นแบบนี้ทั้งหมด ต่างจาก k-nearest neighbour ที่ต้องเก็บข้อมูลทุกแถวไว้. และ "(if any)" ที่ต่อท้ายขั้นที่ 1 เตือนว่าบางอัลกอริทึม เช่น k-means ในหัวข้อ 12 ไม่มีสูตรพารามิเตอร์ให้เขียนแบบนี้.

1B. ประเภทของ Machine Learning และหน้าตาของ Dataset

ก่อนจะเลือกสูตร ต้องรู้ก่อนว่าโจทย์เป็นประเภทไหน เพราะประเภทของโจทย์เป็นตัวกำหนดทั้ง cost function และตัววัดผล. สไลด์หน้า 24 แบ่งด้วยคำถามเดียวคือ "มีเฉลยให้หรือไม่".

ตารางสามชุดบนสไลด์ใช้ข้อมูลบ้านชุดเดียวกันแต่เปลี่ยนคอลัมน์คำตอบ ซึ่งอธิบายความต่างได้ดีกว่าคำนิยาม. ชุดแรก: Size = 100, 200, 300 คู่กับ House Price = 1,000,000 / 2,000,000 / ??????? โดยมีข้อความ Correct Answers given กำกับ — คำตอบที่ต้องเดาคือ ตัวเลข จึงเป็น Regression problems ที่ทำนายผลลัพธ์แบบ continuous (ราคาจะเป็น 2,750,431 บาทก็ได้ ไม่ต้องลงตัว). ชุดที่สอง: Size 100/200/300 กับ Width 30/10/100 คู่กับคอลัมน์ Sale = Available / Sold / ????? ซึ่งก็มี Correct Answers given เหมือนกัน แต่คำตอบเป็น ป้ายชื่อ จึงเป็น Classification problems ที่ทำนายผลลัพธ์แบบ discrete (มีได้แค่ Sold กับ Available ไม่มี "ครึ่ง Sold"). ชุดที่สาม: มีแค่ Size กับ Width ไม่มีคอลัมน์คำตอบเลย กำกับว่า No Correct Answers given — นี่คือ unsupervised learning ที่ได้แต่จัดกลุ่มจุดที่คล้ายกัน (ภาพขวาสุดวงกลุ่มจุดเป็นสองก้อน) ซึ่งคือ k-means ในหัวข้อ 12.

สองคำที่สไลด์ใช้แยกบทบาทของ \(h\) ต้องจำให้แม่น: supervised learning ให้ \(h\) เป็น predictive model (ทำนายค่าที่ยังไม่รู้) ส่วน unsupervised learning ให้ \(h\) เป็น descriptive model (บรรยายโครงสร้างของข้อมูลที่มี ไม่ได้ทำนายอะไร). กล่องมุมล่างซ้ายยังระบุ Other Learning types อีกสองแบบที่ไม่ได้ลงลึกในวิชานี้คือ Semi-supervised Learning (มีเฉลยบางส่วน เช่น ติดป้ายไว้ 100 ภาพจาก 10,000 ภาพ) และ Reinforcement Learning (ไม่มีเฉลย แต่มีรางวัล/บทลงโทษป้อนกลับ เช่น เกม). สไลด์หน้า 25 ต่อจากนี้เป็นแผนผังรวมชื่ออัลกอริทึม ML ทั้งตระกูล (Clustering, Dimensionality Reduction, Regression, Regularization, Decision Tree, Bayesian, Neural Networks ฯลฯ) ซึ่งเป็นหน้าคั่นบทให้เห็นภาพกว้างว่าสิ่งที่เราเรียนสองสามตัวนี้อยู่ตรงไหนของแผนที่.

หน้านี้กำหนดสัญกรณ์ที่ใช้ยาวไปจนจบวิชา. ข้อมูลถูกจัดเป็น "a matrix with rows and columns" โดยคอลัมน์เรียกว่า feature และแต่ละแถวคือ instance หนึ่งตัวอย่าง. ดูจากตารางตัวอย่างบนสไลด์: แถวแรกคือบ้านที่ year_built = 2015, bedrooms = 3, bathrooms = 2, sqft_living = 1800, lot_size = 4000, neighborhood = Downtown, condition = Good, price = 450000; แถวที่สองเป็นบ้านปี 2012 ที่มี 4 ห้องนอน 3 ห้องน้ำ ราคา 620000. สไลด์แยก feature เป็นสองชนิด — Numeric ได้แก่ bedrooms, bathrooms, lot_size, sqft_living, price และ Categorical (Ordinal หรือ Nominal) ได้แก่ neighborhood, condition (ซึ่งเป็น ordinal เพราะ Fair < Good < Excellent เรียงลำดับได้) และ year_built ที่สไลด์หมายเหตุว่า "depends on your intention" — จะมองเป็นตัวเลข (บ้านใหม่กว่าแพงกว่า) หรือมองเป็นหมวดหมู่ (ยุคของการก่อสร้าง) ก็ได้ แล้วแต่ว่าจะให้โมเดลตีความอย่างไร.

สัญกรณ์ที่ทำสีไว้: \(x\) = input variable / input features / predictors / independent variable เขียนเป็นชุด \(x=\{x_1,x_2,\dots,x_n\}\); และ \(y\) = output variable / target feature / outcome / dependent variable เขียนเป็น \(y=\{y_1,y_2,\dots,y_n\}\). ที่ต้องระวังคือคำ สี่คำต่อหนึ่งความหมาย — ข้อสอบชอบใช้คำที่เราไม่คุ้น เช่น ถามถึง "independent variable" ซึ่งก็คือ \(x\) นั่นเอง. สุดท้ายคือรูปของชุดข้อมูลฝึก: Training examples = \(\{(x^{(1)},y^{(1)}),(x^{(2)},y^{(2)}),\dots,(x^{(m)},y^{(m)})\}\) โดย \(m\) = number of training examples. ต้องแยกให้ออกระหว่าง \(n\) (จำนวน feature = จำนวนคอลัมน์ = ความกว้าง) กับ \(m\) (จำนวนตัวอย่าง = จำนวนแถว = ความสูง) เพราะสูตร cost function หารด้วย \(m\) เสมอ ไม่ใช่ \(n\). ในตารางตัวอย่างนี้ ถ้านับ price เป็น \(y\) จะได้ \(n = 7\) feature และ \(m = 8\) แถว.

2. Linear Regression: จากจุดสองจุดสู่สมการเส้นตรง

นิยามบนสไลด์: linear regression เป็น supervised learning algorithm ที่ "fits a linear function to labeled data to predict continuous unlabeled points" — สรุปเป็นประโยคเดียวคือ Given labeled points (X, y), learn weights in a linear function to predict y for new X.. อ่านทีละคำ: labeled points คือข้อมูลที่มีเฉลย, learn weights คือหาค่า \(\theta\), for new X คือใช้กับข้อมูลที่ไม่เคยเห็น. ที่มาของชื่อ "regression" มาจาก regression analysis ทางสถิติซึ่งศึกษาว่า input features สัมพันธ์กับ target features อย่างไร — ไม่ได้แปลว่า "ถอยหลัง" อย่างที่ชื่ออาจชวนเข้าใจผิด. กราฟสองอันในสไลด์ใช้ชุดข้อมูล Boston Housing เดียวกัน โดยแกนนอน \(rm\) คือจำนวนห้องเฉลี่ยต่อบ้าน (ราว 3.5–9) และแกนตั้ง \(medv\) คือราคากลางของบ้าน (0–50): ฝั่งซ้ายลากเส้นตรงเส้นเดียวผ่านกลุ่มจุด ฝั่งขวาลากเส้นโค้ง. เส้นโค้งแนบจุดได้ดีกว่าในช่วง \(rm < 5\) ที่ราคาลดแล้วเชิดขึ้น แต่ก็เสี่ยงจะไล่ตาม noise — ความตึงเครียดระหว่างสองเส้นนี้คือหัวข้อ 10 (bias vs variance) ทั้งหัวข้อ.

Linear regression = ทำนายตัวเลข (เช่นราคา) ด้วยสมการเส้นตรง สไลด์หน้า 28 แยกเป็นสองกรณีที่ทำสีไว้ คือ Linear regression with one variable และ Linear regression with multiple variables. กรณีตัวแปรเดียวใช้ hypothesis

\(\theta_0\) คือ "จุดตัดแกน y" (ค่าตอน \(x=0\)), \(\theta_1\) คือ "ความชัน" (x เพิ่ม 1 หน่วย y เพิ่มกี่หน่วย)

หลายตัวแปร: เมื่อมี feature หลายตัว (ขนาดบ้าน \(x_1\), จำนวนห้องนอน \(x_2\)) แค่บวก term เพิ่ม โครงสร้างเดิมทุกประการ:

สไลด์ย่อรูปนี้ให้สั้นลงด้วยเคล็ดลับที่ใช้ตลอดวิชา คือกำหนดให้มี feature ปลอมตัวหนึ่งที่มีค่าเป็น 1 เสมอ:

พอให้ \(x_0=1\) เทอม \(\theta_0 x_0\) ก็เท่ากับ \(\theta_0\) พอดี ทำให้เขียนรวมเป็นผลรวมก้อนเดียวได้ ไม่ต้องแยกเทอมแรกออกมา

เคล็ดนี้สำคัญมากเพราะใน Lesson 2 มันจะกลายเป็น bias unit ของแต่ละชั้นในโครงข่าย — node พิเศษที่ปล่อยค่า 1 ออกมาตลอดเวลา.

3. Cost Function & Gradient Descent: ทำไมสูตร \(\theta := \theta - \alpha \,\partial J/\partial\theta\) ถึงเดินเข้าหาค่าต่ำสุด

3.1 Cost function = ตัววัดว่าเส้นของเรา "ผิด" แค่ไหน

สไลด์หน้า 29 นิยามว่า "the methods to calculate errors of a model is a cost function \(J(\theta)\)" และตั้งเป้าว่า "Goal: Minimize cost function — choose \(\theta_0,\theta_1,\dots,\theta_n\) to minimize the sum of the squared errors". สูตรที่ใช้คือ Mean Square Error (MSE):

ไล่ทุกตัวอย่าง: (ค่าทำนาย − ค่าจริง) ยกกำลังสอง แล้วเฉลี่ย — ยิ่งเส้นห่างจากจุดมาก ค่า J ยิ่งสูง

สไลด์วาดเส้นตรงผ่านจุด \(X_1, X_2, X_3, X_4\) แล้วลากเส้นประแนวตั้งจากแต่ละจุดมาชนเส้น พร้อมตั้งชื่อระยะนั้นว่า \(e_1, e_2, e_3, e_4\) — นั่นคือ \(h_\theta(x^{(i)})-y^{(i)}\) ของแต่ละตัวอย่าง หรือที่สไลด์กำกับใต้สูตรว่า \(e_i\). สิ่งที่ MSE ทำคือเอา \(e_i\) ทั้งสี่มายกกำลังสองแล้วเฉลี่ย. สไลด์ยังให้ทางเลือกอีกแบบไว้ในกรอบคือ MAE (Mean Absolute Error) \(J(\theta)=\frac{1}{m}\sum_{i=1}^{m}\left|h_\theta(x^{(i)})-y^{(i)}\right|\) ซึ่งใช้ค่าสัมบูรณ์แทนกำลังสอง. ความต่างที่ออกสอบได้: MAE ลงโทษความผิดพลาดทุกขนาดเป็นสัดส่วนตรง ๆ จึงทนต่อ outlier ได้ดีกว่า แต่ MSE หาอนุพันธ์ได้ราบรื่นทุกจุด (MAE มีจุดหักที่ศูนย์) จึงเข้ากับ gradient descent ได้ดีกว่า — เหตุผลนี้คือที่มาของการที่วิชานี้ใช้ MSE เป็นหลัก.

ส่วนรูปชามคือกราฟของ \(J(\theta_0,\theta_1)\) ที่สไลด์กำกับว่า "Linear regression with one variable": แต่ละจุดบนพื้นคือ "ลองค่า \(\theta_0,\theta_1\) ชุดหนึ่ง" ความสูงคือ cost ของชุดนั้น (แกนขวาของสไลด์ไล่จาก 100 ถึง 500) จุดต่ำสุดของชามคือ \(\theta\) ที่ดีที่สุด. ชามนี้ นูน (convex) มีจุดต่ำสุดจุดเดียว ไม่มีหลุมหลอก — ไม่ว่าเริ่มที่ไหน การไต่ลงจะเจอจุดเดียวกันเสมอ (ต่างจาก neural network ที่ Lesson 3 จะเจอ cost ไม่นูนอย่างในภาพซ้ายของหน้า 30 ที่มีทั้งเนินและหุบหลายลูก).

3.2 Gradient Descent: เดินลงเขาทีละก้าว

สไลด์หน้านี้อธิบายอัลกอริทึมเป็นสองบรรทัด: "Gradient Descent Algorithm — start with some initial values of parameters, for example \(\theta_0,\theta_1\)" แล้ว "keep updating \(\theta_0,\theta_1\) until we end up at a minimum". เราไม่ต้องลองทุกค่า \(\theta\) — ใช้อัลกอริทึมที่ "ยืนตรงจุดหนึ่งบนชาม ดูความชัน แล้วก้าวลงเขา" ซ้ำไปเรื่อย ๆ:

ค่าใหม่ = ค่าเก่า − (ขนาดก้าว α) × (ความชันของ J ตรงจุดนี้)

เมื่อแทน \(J\) ของ linear regression ลงไปแล้วหาอนุพันธ์ จะได้รูปที่สไลด์ไฮไลต์กรอบเหลืองไว้ ซึ่งเป็นรูปที่ใช้คำนวณจริง:

สไลด์กำกับความหมายของแต่ละตัวไว้ท้ายหน้า: \(m\) = size of the training set, \(x^{(i)}\) = all values of input variable in a training set, \(y^{(i)}\) = all actual values of a training set. และมีเงื่อนไขสำคัญที่ต้องอ่านให้ครบคือ simultaneously update the parameters โดยสไลด์เขียนวิธีทำไว้ตรง ๆ ด้วยตัวแปรพัก:

เหตุผลที่ต้องพักค่าไว้ก่อน: ถ้าอัปเดต \(\theta_0\) เสร็จแล้วค่อยคำนวณ \(\partial J/\partial\theta_1\) ความชันตัวที่สองจะถูกคำนวณจาก \(\theta_0\) ตัวใหม่ ซึ่งไม่ใช่ความชันของจุดที่เรายืนอยู่จริง กลายเป็นคนละอัลกอริทึมและอาจไม่ลู่เข้า. ข้อนี้เป็นกับดักข้อสอบยอดนิยมเพราะโค้ดที่เขียนผิดยังรันได้และดูเหมือนทำงานได้.

สไลด์ตั้งโจทย์ว่า "let's explore a simple hypothesis function, say \(\theta_0=0\) so we have \(J(\theta_1)\)" แล้ววาดพาราโบลาสองอันที่มีจุดเริ่มต้นคนละฝั่ง เพื่อไล่ให้ดูว่า Iteration1 พา \(\theta_1\) ไปที่ \(\theta_1'\) และ Iteration2 พาไปต่อที่ \(\theta_1''\) ซึ่งเข้าใกล้ก้นชามทั้งคู่ แม้ทิศการเคลื่อนที่ของสองภาพจะสวนทางกัน. ทำไมเครื่องหมายลบทำให้เดินเข้าหาจุดต่ำสุดได้ทั้งสองทาง — คำนวณเป็นกรณี ๆ:

เครื่องหมายลบจึงทำหน้าที่ "กลับทิศให้เข้าหาจุดต่ำสุดเสมอ" — เหตุผลที่สูตรเป็น \(-\) ไม่ใช่ \(+\). ถ้าเปลี่ยนเป็นบวกจะกลายเป็น gradient ascent ซึ่งไต่ขึ้นยอดเขาแทน.

3.3 Learning Rate α: เล็กไป ใหญ่ไป และวิธีตรวจ

กล่องเหลืองมุมล่างขวาของสไลด์คือกุญแจของหน้านี้: เริ่มจาก \(\theta_j := \theta_j - \alpha\frac{\partial J(\theta_j)}{\partial\theta_j}\) แล้วเขียนว่า "Ideally \(\theta_j := \theta_j - \alpha(0)\)". อ่านว่า: พอถึงก้นชาม ความชันเป็น 0 สูตรจึงกลายเป็น \(\theta_j := \theta_j - 0\) คือ หยุดขยับเอง ไม่ต้องมีใครสั่งหยุด และระหว่างทางความชันก็หดลงเรื่อย ๆ ตามที่เราคำนวณไว้ข้างบน ทำให้ก้าวสั้นลงอัตโนมัติแม้ \(\alpha\) จะคงที่. ส่วนสองกราฟด้านบนเทียบกรณีสุดขั้วสองแบบ: "if \(\alpha\) is too small" ก้าวจิ๋วมากจนต้องวนนับหมื่นรอบ และ "if \(\alpha\) is too large" ก้าวข้ามก้นชามไปโผล่อีกฝั่งที่สูงกว่าเดิม.

วิธีตรวจว่า \(\alpha\) เหมาะหรือไม่ อาจารย์ทำสีไว้ชัดเจนว่า Debugging gradient descent. ให้ plot the cost function \(J(\theta)\) เทียบกับจำนวน iteration โดย "ideally \(J(\theta)\) should decrease over a number of iterations". กราฟบนที่ชื่อ Convergence คือรูปที่ถูกต้อง: cost หล่นจากราว 270 ลงมาเหลือราว 57 ภายในสิบรอบแรกแล้วนิ่งยาวจนถึงรอบที่ 100 — แบนแล้วแปลว่าเจอก้นชามแล้ว เทรนต่อก็ไม่ได้อะไรเพิ่ม. กราฟล่างที่ชื่อ Cost Overshoot คือรูปที่ผิด: cost แนบศูนย์อยู่พักหนึ่งแล้ว พุ่งขึ้นถึงระดับ \(10^{303}\) ราวรอบที่ 90 ซึ่งเป็นเลขมหาศาลระดับใกล้ล้นชนิดข้อมูลของคอมพิวเตอร์ — อาการนี้คือการ diverge ที่เราคำนวณมือไปข้างบนเป๊ะ ๆ เพียงแต่เกิดกับข้อมูลจริง. ถ้าเห็นกราฟแบบล่าง วิธีแก้คือ ลด \(\alpha\) (เช่นจาก 0.25 เหลือ 0.05) ไม่ใช่เพิ่มจำนวนรอบ.

สรุปผลของ \(\alpha\) (สไลด์หน้า 32–33):

• \(\alpha\) เล็กเกินไป — ก้าวเล็ก ต้องวนหลายรอบกว่าจะถึงก้นชาม (ช้าแต่ปลอดภัย ไม่พัง)
• \(\alpha\) ใหญ่เกินไป — ก้าวข้ามจุดต่ำสุด แกว่งไปมา หรือ diverge (ตัวอย่างคำนวณข้างบน)
• \(\alpha\) พอดี — cost ลดเร็วช่วงต้นแล้วค่อย ๆ แบนราบ เหมือนกราฟ Convergence
• วิธีเช็ค: พล็อต \(J\) เทียบกับจำนวนรอบเสมอ อย่าดูแค่ค่าสุดท้าย

3A. ทำไมต้องใช้ Parameter Learning ทั้งที่บางทีแก้สมการตรง ๆ ได้

คำถามที่คนเรียนใหม่มักติดคือ "ในเมื่อหัวข้อ 2 เราแก้ระบบสมการสามแถวหา \(\theta\) ได้เป๊ะ ๆ แล้ว ทำไมต้องมานั่งไต่ทีละก้าวให้เสียเวลา?" สไลด์หน้า 37 ตอบไว้ครบสามเหตุผล.

เหตุผลแรก: "in situations where analytical solutions are feasible, it is recommended to solve for the model parameters analytically. However, in cases where analytical solutions are not possible, optimization algorithms such as gradient descent can be utilized." — อ่านให้ดี อาจารย์ แนะนำให้ใช้วิธีแก้สมการตรง ๆ ก่อน ถ้าทำได้ gradient descent เป็นแผนสำรองเมื่อแก้ตรง ๆ ไม่ได้ ซึ่งเป็นประโยคที่ข้อสอบชอบกลับด้าน. สำหรับ linear regression วิธีตรง ๆ นั้นมีชื่อว่า normal equation \(\theta=(X^\top X)^{-1}X^\top y\) และสไลด์ก็เตือนข้อจำกัดของมันไว้ว่า "this method may not always be feasible for very large datasets, as it involves inverting a matrix, which can be computationally expensive for big data" — การหาเมทริกซ์ผกผันของเมทริกซ์ขนาด \(n\times n\) มีต้นทุนราว \(n^3\) ดังนั้นถ้ามี 10,000 feature ต้นทุนจะอยู่ระดับ \(10^{12}\) ซึ่งช้าเกินรับไหว ขณะที่ gradient descent ต้นทุนต่อรอบโตแบบเชิงเส้นกับจำนวน feature เท่านั้น.

เหตุผลที่สอง: "in many cases, the complete graph may not be visible, particularly in high-dimensional datasets." — เรา มองไม่เห็นชามทั้งใบ. รูปชามสวย ๆ ในหน้า 29 วาดได้เพราะมีพารามิเตอร์แค่ 2 ตัว (\(\theta_0,\theta_1\)) จึงพล็อตเป็น 3 มิติได้; พอมี 3 พารามิเตอร์ก็ต้องใช้ 4 มิติซึ่งวาดไม่ได้แล้ว และโครงข่ายใน Lesson 4 มีพารามิเตอร์เป็นแสน. gradient descent จึงมีค่าตรงที่มัน ไม่ต้องเห็นภาพรวม — รู้แค่ความชันใต้เท้าตัวเองก็เดินลงได้ เหมือนคนเดินลงเขาในหมอกหนา.

เหตุผลที่สาม: "to compare possible set of parameters, machine learning can be employed, but this approach is limited by the computational resources available." — ถ้าจะลองทุกชุดค่า \(\theta\) ให้ครบ สมมติแค่มี 10 พารามิเตอร์และลองค่าละ 100 ค่า ก็ต้องลอง \(100^{10}=10^{20}\) ชุด ซึ่งเครื่องใด ๆ ในโลกก็ทำไม่ไหว. gradient descent ตัดจำนวนการลองจากเลขยกกำลังเหลือแค่ "ไม่กี่พันรอบ" เพราะมันใช้ข้อมูลความชันเป็นเข็มทิศแทนการสุ่ม.

4. Feature Scaling: ทำไมต้อง Normalize ก่อนเทรน

ปัญหาที่หน้านี้ตั้งขึ้น มาจากตัวเลขจริงในตาราง: บ้านสามหลังมี size = 1000, 2000, 3000 แต่ #bedroom = 3, 4, 4 และสไลด์ระบุช่วงที่เป็นไปได้ว่า \(1000 \le x_1 \le 5000\) กับ \(1 \le x_2 \le 5\). สังเกตว่าช่วงของ \(x_1\) กว้าง 4000 หน่วย ส่วน \(x_2\) กว้างแค่ 4 หน่วย — ต่างกันพันเท่า. ผลที่ตามมาคือ เมื่อขยับ \(\theta_1\) (สัมประสิทธิ์ของขนาดบ้าน) ไปนิดเดียว ค่าทำนายกระโดดมหาศาล แต่ขยับ \(\theta_2\) เท่ากันกลับแทบไม่มีผล. ค่า cost จึงไวต่อ \(\theta_1\) มากกว่า \(\theta_2\) หลายเท่า และ contour (เส้นระดับความสูงเท่ากันของชาม) ถูกบีบเป็นวงรีแคบยาว แทนที่จะเป็นวงกลม ตามภาพซ้ายของสไลด์ที่เครื่องหมายกากบาทเริ่มต้นอยู่ไกลจากใจกลางวงรี. บนภูมิประเทศแบบนี้ ทิศชันที่สุดไม่ได้ชี้ไปที่ก้นชาม gradient descent จึงเดินซิกแซกข้ามหุบไปมา ใช้รอบเยอะกว่าจะถึง. พอปรับสเกลให้ใกล้กัน contour กลมขึ้นแบบภาพขวา ทิศชันที่สุดก็ชี้ตรงเข้าก้นชามพอดี. อาจารย์สรุปเป็นประโยคเดียวว่า "the idea is to make sure that features are almost in a same scale (feature scaling)" และเสนอสองวิธีคือ min-max normalization กับ mean normalization.

สูตร min-max normalization ในสไลด์หน้า 35:

วัดว่าค่านี้อยู่ "กี่ส่วนของช่วง" ตั้งแต่ต่ำสุดถึงสูงสุด — ผลลัพธ์อยู่ใน [0, 1] เสมอ

วิธีที่สองที่สไลด์หน้า 36 เสนอคือ Mean normalization: "subtracts the mean value of feature X, and divides the outcome by the standard deviation of X" เขียนเป็น

ผลลัพธ์เรียกว่า z-score และสไลด์ย้ำข้อแตกต่างสองข้อ: (1) "unlike the normalized values, they have no predefined minimum and maximum" — ไม่มีขอบเขตตายตัวแบบ [0,1]; (2) "better classifying future examples especially when independent variables have a normal distribution shape" — เหมาะกว่าเมื่อข้อมูลกระจายเป็นรูประฆัง.

5. Classification & Logistic Regression: จากค่า θ สู่เส้นแบ่งที่มองเห็น

นิยามของงาน classification คือ Given a set of labeled points and want to use these to predict discrete unlabeled points — โครงเดียวกับ linear regression ทุกคำ ต่างกันคำเดียวคือผลลัพธ์เป็น discrete แทน continuous. สองกราฟบนสไลด์ใช้โจทย์การรับเข้ามหาวิทยาลัยเหมือนกันแต่ข้อมูลคนละแบบ. ฝั่ง Linear Classifier: แกนนอนคือคะแนน Exam 1 (ราว 30–100) แกนตั้งคือคะแนน Exam 2 (ราว 30–100) และเส้นตรงเส้นเดียวแยก Admitted ออกจาก Not admitted ได้เกือบหมด — อ่านเป็นกฎง่าย ๆ ว่า "ผลรวมคะแนนสองวิชาต้องถึงเกณฑ์". ฝั่ง Non-Linear Classifier: ข้อมูล Test 1 กับ Test 2 พันกันเป็นก้นหอยสองเกลียว ไม่มีเส้นตรงเส้นไหนแบ่งได้เลย ต้องใช้เส้นโค้งที่ม้วนตามเกลียว. ความต่างนี้คือเหตุผลทั้งหมดที่ต้องมี hidden layer ใน Lesson 2 — เพราะ logistic regression ตัวเดียวให้เส้นตรงได้อย่างเดียว (เว้นแต่จะเติม feature ยกกำลังเองอย่างในหน้า 43).

Binary Classification คือการ predicting discrete output ที่มีเพียง 2 classes -- \(y \in \{0,1\}\) โดยสไลด์นิยามความหมายของเลขสองตัวไว้ชัด: "1" denotes positive class (finding something) และ "0" denotes negative class (absenting something). จุดที่ต้องระวังคือคำว่า positive ไม่ได้แปลว่า "ดี" — มันแปลว่า "เจอสิ่งที่กำลังตามหา". ในตัวอย่าง Email classification สิ่งที่ตามหาคือสแปม ดังนั้น "spam = 1 = positive" ทั้งที่สแปมเป็นเรื่องแย่. ความเข้าใจนี้จำเป็นตรง ๆ กับหัวข้อ 7 เพราะ precision และ recall นับเฉพาะคลาส positive เท่านั้น ถ้าตีความ positive ผิด ตัวเลขทั้งชุดจะพลิก. อีกตัวอย่างคือ Housing Sale Prediction ที่กราฟแกน Size–Width แยก Sold (จุดที่กระจุกฝั่งล่างขวา) ออกจาก Available (ฝั่งบนซ้าย) ด้วยเส้นทแยง ซึ่งเราจะคำนวณเส้นนี้จริงในหน้า 43.

ประโยคนิยามคือ "Logistic Regression utilizes the probability to determine the likelihood of the tested example 'x' being classified as a positive class ('1')" พร้อมสัญกรณ์บนสไลด์ว่า

อ่านว่า: ผลลัพธ์ของโมเดลไม่ใช่คำตอบ 0/1 โดยตรง แต่เป็น "ความน่าจะเป็นที่คำตอบจะเป็น 1 เมื่อเห็นข้อมูล x นี้"

จุดนี้คือสิ่งที่ทำให้ logistic regression ต่างจากการลากเส้นเฉย ๆ: ถ้าได้ \(h_\theta(x)=0.83\) แปลว่าโมเดลบอกว่า "ผมมั่นใจ 83% ว่าตัวอย่างนี้เป็นคลาสบวก" ไม่ใช่ "คำตอบคือ 0.83". การจะเปลี่ยนความมั่นใจเป็นคำตอบต้องมี threshold อีกชั้นหนึ่ง (ปกติ 0.5) ซึ่งเป็นตัวที่หัวข้อ 7 จะเลื่อนไปมาเพื่อสร้าง ROC curve. ตัวอย่างในสไลด์ใช้ข้อมูลนักศึกษาที่มี Lab score (ราว 15–32) กับ Exam score (ราว 5–70) และแบ่งว่าใครได้ Grade A — จะเห็นว่าจุด Grade A กระจุกอยู่ฝั่งที่ทั้ง lab และ exam สูง ซึ่งพอเดาได้ว่ามีเส้นแบ่งเชิงเส้นอยู่จริง.

หน้านี้เล่าเหตุผลว่าทำไมต้องมี sigmoid ด้วยตัวอย่างที่คำนวณตามได้: Logistic regression ใช้กับ classification ทั้งที่เบื้องหลังใช้สมการของ linear regression เพื่อสร้าง relationship between input and target variables. ข้อมูลในตารางมีสามแถว — size 1000 → price class 0 (low), size 2000 → 1 (high), size 3000 → 1 (high). ถ้าลอง fitting a linear regression ตรง ๆ ตามภาพซ้าย จะได้เส้น \(y=\theta_0+\theta_1x\) ที่ทะลุขึ้นเหนือ 1 และลงต่ำกว่า 0 เมื่อ \(x\) โตหรือเล็กเกินช่วงข้อมูล ซึ่งไร้ความหมายทันที: บ้าน 10,000 ตร.ฟุต จะได้ค่าทำนายอย่าง 4.2 ทั้งที่คลาสมีแค่ 0 กับ 1. ทางออกที่สไลด์เสนอคือใช้ Logistic function ซึ่งเป็น "the inverse of logit, which is a transformation from [-inf, inf] to [0,1]" ได้ภาพขวาที่เส้นกลายเป็นรูปตัว S แนบ 0 ทางซ้ายและแนบ 1 ทางขวา — ไม่มีวันหลุดกรอบ. สังเกตคำว่า mapping ที่สไลด์ใช้: เราไม่ได้เปลี่ยนสมการเชิงเส้นข้างในเลย แค่เอาผลลัพธ์ของมันไป "บีบ" อีกที.

สไลด์เริ่มจากกรณี two input variables แล้วจัดรูปสมการเส้นตรงใหม่ทีละขั้น: เส้นแบ่งบนระนาบเขียนได้เป็น \(x_2=\theta_0+\theta_1x_1\) จากนั้น "ย้ายข้างสมการ" (คำที่อาจารย์เขียนกำกับไว้เป็นภาษาไทยบนสไลด์) ได้ \(0=\theta_0+\theta_1x_1-x_2\) ซึ่งเขียนรูปทั่วไปว่า \(0=\theta_0+\theta_1x_1+\theta_2x_2\). ประโยชน์ของการจัดรูปแบบนี้คือทำให้ "อยู่ฝั่งไหนของเส้น" กลายเป็นแค่เรื่องเครื่องหมายของนิพจน์เดียว. หลังเทรนได้ \(\theta_0,\theta_1,\theta_2\) แล้ว ค่า \(\theta_0+\theta_1x_1+\theta_2x_2\) อยู่ในช่วง [-inf, inf] จึงต้อง Mapping ไปเป็น [0,1] และสไลด์ระบุเกณฑ์ไว้สามบรรทัด: ถ้าค่าเท่ากับ 0 พอดี → "unpredictable, predict y = 0.5"; ถ้ามากกว่า 0 → predict y = "1"; ถ้าน้อยกว่า 0 → predict y = "0". ฟังก์ชันที่ทำหน้าที่บีบคือ sigmoid ในกรอบเหลือง:

Decision Boundary คือ "a boundary that separates the area of different classes (in this example is where y = 1 and where y = 0)". สไลด์ตั้งโจทย์ไว้สองข้อพร้อมค่า \(\theta\) จริงและจุดทดสอบจริง — สองข้อนี้เป็นแบบฝึกหัดที่มีโอกาสออกสอบสูงมาก เพราะคำนวณมือได้ใน 30 วินาทีถ้าเข้าใจ.

6. Cost Function ของ Classification: ทำไมใช้ Log Loss แทน MSE

ถ้าเอา MSE ไปใช้กับ sigmoid จะได้ cost ที่ไม่นูน (มีหลุมหลอกหลายจุด) gradient descent จึงอาจติดหลุมได้. สไลด์หน้า 44 จึงตั้ง Goal: find parameters \(\theta\) to minimize J(θ) แล้วเปลี่ยนไปใช้ Cross-Entropy / Log Loss. เริ่มจากกรณี one training example คือมีแค่ \((x^{(1)},y^{(1)})\):

มีเพียงเทอมเดียวที่ "ทำงาน" เสมอ: ถ้า \(y=1\) เหลือ \(-\log h\); ถ้า \(y=0\) เหลือ \(-\log(1-h)\)

สไลด์อธิบาย intuition ด้วยการแยกสองกรณีตามค่า \(y\) แล้ววาดกราฟให้ดูคู่กัน (แกนนอนคือ \(h_\theta(x)\) ตั้งแต่ 0.0 ถึง 1.0 แกนตั้งคือ Cost ตั้งแต่ 0 ถึงราว 10):

• ถ้า 𝒚 (1) = 1 เทอมที่สองหายไปทั้งก้อน (เพราะ \(1-y=0\)) เหลือ \(J(\theta)=-y^{(1)}\log h_\theta(x^{(1)})\) และสไลด์กำกับไว้ว่า "if \(h_\theta(x) \to 1\) Cost → 0" กับ "if \(h_\theta(x) \to 0\) Cost → ∞"
• ถ้า 𝒚 (1) = 0 เทอมแรกหายไป (เพราะ \(y=0\)) เหลือ \(J(\theta)=-(1-y^{(1)})\log(1-h_\theta(x^{(1)}))\) และเงื่อนไขกลับด้าน: "if \(h_\theta(x) \to 0\) Cost → 0" กับ "if \(h_\theta(x) \to 1\) Cost → ∞"

กราฟสองอันจึงเป็นภาพสะท้อนกันในแนวตั้ง — คู่เงื่อนไข 𝒚 (1) = 1 𝒚 (1) = 0 นี้เป็นสิ่งที่ข้อสอบชอบสลับให้ผิด. สาระคือกลไกเดียวกันทั้งสองกรณี: ลงโทษหนักเมื่อมั่นใจผิด ไม่ลงโทษเมื่อมั่นใจถูก.

เมื่อรวมทุกตัวอย่างเข้าด้วยกันจะได้สูตรสำหรับ all training example (Cross-Entropy Loss or Log Loss) ตามที่สไลด์เขียนไว้:

เรื่องที่น่าทึ่งที่สุดของหน้า 45 คือสูตรอัปเดตพารามิเตอร์ของ logistic regression หน้าตาเหมือน linear regression ทุกตัวอักษร:

ต่างกันแค่ตรงที่สไลด์เขียนกำกับไว้ว่า "where \(h=g(z)=\frac{1}{1+e^{-z}}\), given \(z=\sum_{i=0}^{n}\theta_ix_i\)" — คือ \(h\) ถูกส่งผ่าน sigmoid ก่อน ส่วนโครงสูตรเดิมเป๊ะ และยังต้อง simultaneously update ด้วยตัวแปรพัก \(\text{Tmp}_0,\text{Tmp}_1,\dots,\text{Tmp}_n\) เหมือนเดิม. เหตุผลที่ลดรูปได้ขนาดนี้: อนุพันธ์ของ log loss ไปตัดกับอนุพันธ์ของ sigmoid \(g'(z)=g(z)(1-g(z))\) พอดี ทำให้เหลือแค่ "ค่าทำนาย − ค่าจริง" คูณ feature (สไลด์ให้ลิงก์พิสูจน์ไว้ และ Lesson 3 จะพิสูจน์เต็ม). ผลเชิงปฏิบัติคือ: ถ้าเขียนโค้ด gradient descent ของ regression ได้แล้ว เปลี่ยนไปทำ classification แค่เพิ่มบรรทัด sigmoid บรรทัดเดียว.

7. Metrics: Confusion Matrix, Precision/Recall และ ROC/AUC

สไลด์นิยาม confusion matrix ว่าเป็น "table that summarizes how successful a classification model is at predicting examples belonging to various classes" แล้วให้สี่สูตรที่ต้องแยกให้ออก. เมื่อทำนายแบบ 2 คลาส ผลแต่ละตัวอย่างตกใน 4 ช่อง: TP (ทำนายบวก จริงบวก), TN (ทำนายลบ จริงลบ), FP (ทำนายบวก แต่จริงลบ), FN (ทำนายลบ แต่จริงบวก).

precision ถามว่า "ที่ทำนายว่าใช่ ถูกกี่ %" ส่วน recall ถามว่า "ของจริงทั้งหมด จับได้กี่ %" — ตัวเศษเหมือนกัน ต่างกันที่ตัวส่วน

ตัวอย่างบนสไลด์เป็นตัวตรวจจับเลข "5" จากภาพลายมือ โดยกำหนดให้เลข 5 เป็น positive class. อ่านตัวเลขที่อาจารย์กำกับไว้: ช่อง Predicted Positive มีภาพอยู่ 4 ภาพ ซึ่งเป็นเลข 5 จริง 3 ภาพ ⇒ Precision = 3 out of 4 = 0.75; ส่วนแถว Actual Positive มีเลข 5 จริงทั้งหมด 5 ภาพ แต่ตรวจเจอ 3 ภาพ ⇒ Recall = 3 out of 5 = 0.60. คำนวณ \(F_1\) ได้ \(2(0.75)(0.60)/(0.75+0.60)=0.667\). สิ่งที่ตัวเลขคู่นี้บอกคือ "เวลาบอกว่าใช่ก็ค่อนข้างเชื่อได้ (75%) แต่พลาดของจริงไปถึง 2 ใน 5".

แถบล่างขวาของสไลด์สาธิต Precision Recall Trade-off ด้วยตัวเลขสามชุดจากการเลื่อน threshold ไปทางขวาทีละขั้นบนแถวของภาพที่เรียงตามคะแนนความมั่นใจ:

ไล่ตัวเลขตามแถวจะเห็นกฎที่สไลด์เขียนไว้ว่า "increasing precision reduces recall (vice versa)" เป็นรูปธรรม: precision ไต่ขึ้น 75 → 80 → 100% ขณะที่ recall ร่วง 100 → 67 → 50%. เหตุผลเชิงกลไกคือการขยับ threshold ขึ้นทำให้ทำนายบวกน้อยลง ⇒ FP ลด (precision ขึ้น) แต่ FN เพิ่ม (recall ลง) — ตัวเศษ TP ก็ลดลงด้วยทั้งสองฝั่ง. การเลือกจุดที่เหมาะจึงขึ้นกับงาน: คัดกรองมะเร็งต้องการ recall สูง (ห้ามพลาดผู้ป่วย) ส่วนระบบกรองสแปมต้องการ precision สูง (ห้ามทิ้งอีเมลสำคัญ).

ROC Curve เป็นการแสดงภาพของ performance of a binary classifier เมื่อค่า threshold ถูกเปลี่ยนไปเรื่อย ๆ โดยพล็อต true positive rate (TPR) เทียบกับ false positive rate (FPR) ที่ทุกค่า threshold ตามสูตร

ข้อความบนกราฟของสไลด์อธิบายคุณสมบัติสำคัญสองข้อไว้: เส้นทึบ "will always start at (0.0, 0.0) and end at (1.0, 1.0)" เพราะที่ threshold สูงสุดไม่มีอะไรถูกทำนายเป็นบวกเลย และที่ threshold ต่ำสุดทุกอย่างถูกทำนายเป็นบวกหมด; และ "the closer we get to (0.0, 1.0), the more accurate the model" คือยิ่งโค้งชิดมุมซ้ายบนยิ่งดี. ส่วนเส้นประทแยงคือโมเดลที่ทำนายตามอัตรา 0/1 ในข้อมูลแบบสุ่ม ซึ่ง "the true positive rate is equal to the false positive rate". สไลด์ยังบอกด้วยว่า ROC มีประโยชน์เพราะให้ตัวเลขเดียวคือพื้นที่ใต้กราฟ (AUC) ไว้เทียบโมเดลต่างรุ่น และช่วยเลือก appropriate threshold โดยดู trade-off ระหว่าง TPR กับ FPR ได้พร้อมกัน.

8. Multiclass: One-vs-Rest และ Softmax

หน้านี้ขยายโจทย์เดิมจากสองคลาสเป็นสามคลาส: "classification of data when we have more than two categories" โดย \(y=\{0,1,\dots,n\}\). ตารางบนสไลด์ให้ตัวอย่างจริงสามแถว — บ้านขนาด 50 ตร.วา กว้าง 5 อยู่ในสถานะ Loan; ขนาด 100 กว้าง 10 อยู่ในสถานะ Sold; ขนาด 200 กว้าง 20 อยู่ในสถานะ Available. จุดสำคัญที่ต้องเข้าใจก่อนไปต่อคือ สามคลาสนี้ไม่มีลำดับ: Loan ไม่ได้ "มากกว่า" Sold และ Sold ไม่ได้ "อยู่ระหว่าง" Loan กับ Available. ดังนั้นการใช้ linear regression ทำนายเลข 0/1/2 แล้วปัดเศษจึงผิดตั้งแต่ตั้งโจทย์ — เพราะมันบังคับให้เกิดลำดับที่ไม่มีอยู่จริง. สองวิธีที่สไลด์เสนอ (one-vs-rest กับ softmax) ต่างก็หลบปัญหานี้ด้วยการให้ "คะแนนแยกต่อคลาส" แล้วเลือกตัวที่คะแนนสูงสุด.

วิธีแรกคือ One-vs-Rest: train the logistic regression classifier \(h_\theta^{(i)}(x)\) for each class \(i\) (binary) เพื่อทำนายความน่าจะเป็นที่ \(y=i\) จากนั้นเวลาจะทำ prediction กับตัวอย่างใหม่ \(x\) ให้เลือกคลาสที่ maximizes \(h_\theta^{(i)}(x)\) โดยที่ \(h_\theta^{(i)}(x)=P(y=i \mid x;\theta)\) สำหรับ \(i=1,2,3\). วิธีอ่านสามกราฟย่อยบนสไลด์: กราฟแรกเก็บคลาส Loan ไว้เป็นของจริงแล้วรวม Sold กับ Available เป็น "rest" ก้อนเดียว แล้วลากเส้นตรงหนึ่งเส้นแยกสองก้อนนี้; กราฟที่สองทำแบบเดียวกันกับคลาส Available; กราฟที่สามกับคลาส Sold. ผลคือได้โมเดล binary 3 ตัว แต่ละตัวตอบคำถามเดียวว่า "ใช่คลาสนี้หรือไม่". สมมติป้อนบ้านหลังใหม่เข้าไปแล้วได้ \(h^{(1)}=0.3,\ h^{(2)}=0.7,\ h^{(3)}=0.2\) ⇒ ตอบคลาสที่ 2. ข้อสังเกตที่เป็นข้อเสีย: ผลรวม \(0.3+0.7+0.2=1.2\) ไม่เท่ากับ 1 เพราะแต่ละโมเดลถูกฝึกแยกกันไม่เคย "คุยกัน" — และถ้ามี \(k\) คลาสก็ต้องเทรน \(k\) โมเดล.

Softmax แก้ข้อเสียข้างบนด้วยโมเดลเดียว. สไลด์เขียนไว้สามบรรทัด: เป็น "extension of logistic regression to multiple classes", "rather than using k logistic regression models, this method use only one single model" และ "uses softmax function instead of sigmoid". นิยามของฟังก์ชันคือให้ \(t_i=e^{z_i^{[L]}}\) แล้ว

โดยสไลด์อธิบายว่า softmax rescales outputs ให้คะแนนทุกคลาสรวมกันได้ 1 และคืนค่าเป็น probability distribution ของคลาสที่ไม่ทับซ้อนกัน แล้วโมเดลจึงเลือกคลาสที่ความน่าจะเป็นสูงสุด. ส่วน loss ที่สไลด์ให้ไว้คือ

พร้อมหมายเหตุสำคัญว่า \(y_k^{(i)}=1\) เฉพาะ correct class เท่านั้น นอกนั้นเป็น 0 — การเขียนแบบนี้เรียกว่า one-hot encoding และทำให้ผลรวมชั้นใน \(\sum_k\) เหลือเทอมเดียวเสมอ คือ \(-\log\) ของความน่าจะเป็นที่โมเดลให้กับคลาสที่ถูก.

9. Model Evaluation: Train/Validation/Test และ k-fold Cross Validation

Goal ของหัวข้อนี้คือดูว่าโมเดลจะทำงานได้ how well บน unseen examples — คำว่า "unseen" คือหัวใจ เพราะถ้าวัดผลบนข้อมูลที่ใช้เทรน โมเดลที่ "ท่องจำ" ก็ได้คะแนนเต็ม ทั้งที่ทำนายข้อมูลใหม่ไม่ได้เลย. หัวข้อ How to evaluate the model ให้สองทางเลือก:

• แบ่งสามก้อน Training, Validation และ Test Set เช่นสุ่มแบบ 70-15-15 หรือ 60-20-20
• แบ่งสองก้อน Training และ Test Set เช่น 80-20 หรือ 70-30 แล้วทำ Cross Validation บนก้อน training แทนการกันชุด validation แยก

บรรทัดที่อาจารย์ทำสีแดงไว้ทั้งบรรทัดคือ Regression Problems – Linear Regression<==> Classification Problems – Logistic Regression ซึ่งบอกว่าทุกสูตรในหน้านี้มีสองเวอร์ชันคู่กันเสมอ: ฝั่งซ้ายใช้ squared error ฝั่งขวาใช้ log loss. ขั้นตอนสามข้อที่สไลด์ไล่ไว้พร้อมสูตรคือ:

1. Train the model เพื่อหาค่าพารามิเตอร์ \(\theta\) ที่ดีที่สุดโดยใช้ชุด training: $$J_{\text{train}}(\theta)=\frac{1}{m_{\text{train}}}\sum_{i=1}^{m_{\text{train}}}\left(h_\theta(x_{\text{train}}^{(i)})-y_{\text{train}}^{(i)}\right)^2$$
2. ทำ model selections โดยเลือกตัวที่ error น้อยที่สุดบนชุด validation หรือ hold-out set (cross validation): $$J_{cv}(\theta)=\frac{1}{m_{cv}}\sum_{i=1}^{m_{cv}}\left(h_\theta(x_{cv}^{(i)})-y_{cv}^{(i)}\right)^2$$
3. ประเมิน error ของการ generalization ด้วยชุด test set โดยใช้ \(J_{\text{test}}(\theta^{(i)})\) ที่ \(\theta^{(i)}\) คือพารามิเตอร์จากโมเดลที่ error ต่ำสุด: $$J_{\text{test}}(\theta)=\frac{1}{m_{\text{test}}}\sum_{i=1}^{m_{\text{test}}}\left(h_\theta(x_{\text{test}}^{(i)})-y_{\text{test}}^{(i)}\right)^2$$

สังเกตว่าทั้งสามสูตร หน้าตาเหมือนกันเป๊ะ ต่างกันแค่ว่าเอาข้อมูลก้อนไหนมาใส่ — ความต่างที่แท้จริงอยู่ที่ ใครมีสิทธิ์เปลี่ยนแปลงอะไรจากตัวเลขนั้น: \(J_{\text{train}}\) ใช้ปรับ \(\theta\), \(J_{cv}\) ใช้เลือก hyperparameter, ส่วน \(J_{\text{test}}\) ห้ามใช้ปรับอะไรทั้งสิ้น ดูครั้งเดียวตอนจบ. ท้ายสไลด์ยังมีหมายเหตุสามดาวว่า "make sure all three datasets (training, validation, test) have similar statistical properties" — ถ้าเผลอแบ่งข้อมูลโดยเรียงตามเวลาหรือตามพื้นที่ เช่น train เป็นบ้านในเมืองทั้งหมดแต่ test เป็นบ้านชานเมืองทั้งหมด ตัวเลขที่ได้จะไม่มีความหมาย.

Cross-validation คือ resampling procedure ที่ใช้ประเมินโมเดลในกรณีที่ชุด training might not have been homogeneously selected เป็นตัวแทนของข้อมูล หรือกรณีที่มี limited data sample ผลที่ได้คือ "less biased or less optimistic estimate of the model". คำว่า resampling สำคัญมากและมักเป็นตัวเลือกถูกในข้อสอบ: มันแปลว่า "เอาข้อมูลชุดเดิมมาแบ่งใหม่หลายรอบ" ไม่ใช่การไปเก็บข้อมูลเพิ่ม. เหตุผลว่าทำไมต้องทำเช่นนั้นดูได้จากสองกราฟบนสไลด์ที่ใช้แกนเดียวกัน (Mean Squared Error เทียบ Degree of Polynomial): กราฟซ้ายเป็นการแบ่ง validation ครั้งเดียวได้เส้นเดียวที่ดูเรียบร้อย ส่วนกราฟขวาเป็นการแบ่งซ้ำหลายรอบด้วยการสุ่มคนละแบบ ได้เส้นสิบกว่าเส้นที่กระจายห่างกันมาก — บางเส้นบอกว่า degree 2 ดีที่สุด บางเส้นบอกว่า degree 7 ดีที่สุด. บทเรียนคือ ผลจากการแบ่งครั้งเดียวเชื่อไม่ได้ เพราะมันขึ้นกับว่าบังเอิญสุ่มได้ข้อมูลชุดไหน สไลด์จึงกำกับไว้ว่า "error estimates should be average of all the errors".

นิยามของ k -fold Cross Validation มีสามบรรทัด: (1) แบ่งชุด training ออกเป็น k groups หรือ folds ที่มีขนาดใกล้เคียงกัน; (2) fold ที่ถูกกันไว้ถือเป็น validation set และโมเดลถูก fit ด้วยอีก \(k-1\) folds ที่เหลือ; (3) ตัวอย่างเช่นในงาน regression ให้คำนวณ MSE บนข้อมูลใน fold ที่กันไว้. แผนภาพ 5-fold ด้านขวาของสไลด์แสดงห้าแถว แต่ละแถวกันคนละช่วงของข้อมูลไว้ตรวจ — ข้อมูลทุกตัวจึงได้เป็น validation หนึ่งครั้งพอดีและได้เป็น training \(k-1\) ครั้ง ซึ่งเป็นเหตุผลว่าทำไมมันใช้ข้อมูลได้คุ้มกว่าการกันชุด validation ทิ้งไว้ก้อนเดียว.

สไลด์หน้า 53 ไล่ขั้นตอนของ \(k=3\) ไว้ครบ และนี่คือลำดับที่ต้องท่องได้เพราะเป็นข้อสอบเรียงลำดับชั้นดี:

1. ขั้นที่ 1 — Create an 80-20 train-test-split

   ข้อมูลทั้งหมดแบ่งเป็น train 80% / test 20% (test เก็บเข้าลิ้นชัก ยังไม่แตะ)

2. ขั้นที่ 2 — Split the training set into k-folds, say three folds

   เช่นมี 300 แถวในส่วน train ⇒ fold ละ 100 แถว

3. ขั้นที่ 3 — หมุนเวียน 3 รอบ

   รอบ 1: set aside Fold 1 แล้วสร้างโมเดลจาก Fold 2 + Fold 3 แล้ววัดผลบน Fold 1 (เช่นเป็น percentage of accurate results) · รอบ 2: set aside Fold 2 สร้างจาก Fold 1 + Fold 3 แล้ววัดบน Fold 2 · รอบ 3: set aside Fold 3 สร้างจาก Fold 1 + Fold 2 แล้ววัดบน Fold 3

4. ขั้นที่ 4 — Take the average performance across all three folds

   สมมติ error สามรอบ = 0.20, 0.24, 0.22 ⇒ คะแนนของ hyperparameter ชุดนี้ = \(\frac{0.20+0.24+0.22}{3} = 0.22\)

5. ขั้นที่ 5 — Repeat for each set of hyperparameters แล้วเลือกชุดที่ดีที่สุด

   ทำซ้ำทั้งกระบวนการกับ \(\lambda\) หรือ degree ค่าอื่น ๆ แล้วจึงสร้างโมเดลสุดท้าย และค่อยแตะ test 20% ครั้งเดียว

หมายเหตุความคลาดเคลื่อนบนสไลด์ (ต้องรู้ไว้): บรรทัดที่สามของรอบที่ 3 บนสไลด์พิมพ์ว่า "set aside Fold 3 and build a model using Fold 2 and Fold 3" ซึ่งขัดแย้งในตัวเอง — ถ้ากัน Fold 3 ไว้ตรวจแล้วจะเอามันมาเทรนอีกไม่ได้. การอ่านที่ปลอดภัยสำหรับการสอบคือ สร้างโมเดลจาก Fold 1 และ Fold 2 ซึ่งตรงกับนิยามในหน้า 52 ที่ว่า "the model is fit on the remaining \(k-1\) folds". ถ้าข้อสอบให้ตัวเลือกตามตัวอักษรบนสไลด์ ให้ยึดหลักการนี้เป็นตัวตัดสิน.

ข้อสำคัญที่สุดของหัวข้อนี้: test 20% ไม่ถูกแตะจนกว่าเลือก hyperparameter เสร็จ ไม่งั้นตัวเลข test จะ "ถูกมองเห็น" ระหว่างเลือกโมเดลและกลายเป็นตัวเลขที่ดูดีเกินจริง (เหตุผลเดียวกับที่ Lesson 6 §10 ได้ validation 0.8936 สูงกว่า test 0.8845).

10. Bias vs Variance: วินิจฉัยจากกราฟ \(J_{\text{train}}\) กับ \(J_{cv}\)

สไลด์เปิดด้วยคำถามวินิจฉัย: "suppose validation error is high, what problems of a model might be (bias or variance problem)" แล้วให้นิยามสองข้อที่ต้องท่องคู่กัน:

• Underfitting เกิดเมื่อโมเดล too simple จนจับรูปแบบที่ซ่อนอยู่ในข้อมูลไม่ได้ ทำให้ทำงานแย่ ทั้ง บน training และ testing data — สไลด์กำกับว่า (High Bias)
• Overfitting เกิดเมื่อโมเดล too complex จนแนบไปกับ training data มากเกินไป ทำให้ทำงานแย่กับข้อมูลใหม่ที่ไม่เคยเห็น — สไลด์กำกับว่า (High Variance)

ภาพสามคู่บนสไลด์ใช้ข้อมูลราคาบ้านชุดเดียวกันแต่เปลี่ยนสูตรของ \(h\) ซึ่งอ่านเป็นตัวเลขได้ตรง ๆ: ซ้ายสุด \(h_\theta(x)=\theta_0+\theta_1x\) เป็นเส้นตรงที่พลาดความโค้งของข้อมูลช่วงปลาย (High Bias / Underfitting); ตรงกลาง \(h_\theta(x)=\theta_0+\theta_1x+\theta_2x^2\) เป็นเส้นโค้งนุ่ม ๆ ที่ตามแนวโน้มได้พอดี (Good fit); ขวาสุด \(h_\theta(x)=\theta_0+\theta_1x+\theta_2x^2+\theta_3x^3+\theta_4x^4\) เป็นเส้นหยักขึ้นลงที่ลากผ่านทุกจุดข้อมูลเป๊ะ ๆ (High Variance / Overfitting). แถวล่างเล่าเรื่องเดียวกันในงาน classification: เส้นตรง → เส้นโค้งนุ่ม → เส้นหยักซิกแซกที่อ้อมเก็บทุกจุดแม้แต่จุดที่ดูเหมือน noise. จุดที่ต้องดูให้ออกคือภาพ Validation Set ที่วางแยกไว้ทางขวา: เส้นหยักที่แนบ training set ได้สมบูรณ์แบบนั้น พอเจอจุดชุดใหม่ก็ทำนายพลาดทันที เพราะสิ่งที่มันจำไว้คือตำแหน่งของจุดเดิม ไม่ใช่แนวโน้มของข้อมูล.

นิยามง่าย ๆ ของสองเส้นในกราฟ: \(J_{\text{train}}\) = cost บนข้อมูลที่โมเดลเคยเห็น, \(J_{cv}\) = cost บนข้อมูล validation ที่ไม่เคยเห็น ซึ่งสไลด์ให้สูตรไว้ทั้งคู่เป็น squared error หารด้วย \(m_{\text{train}}\) และ \(m_{cv}\) ตามลำดับ. สองค่านี้อ่านคู่กันแล้วบอกโรคของโมเดลได้ทันที และสไลด์เขียนกฎไว้สองบรรทัด: "high bias (underfitting): both \(J_{\text{train}}(\theta)\) and \(J_{cv}(\theta)\) will be high" กับ "high variance (overfitting): \(J_{\text{train}}(\theta)\) will be low and \(J_{cv}(\theta)\) will be high".

อ่านกราฟตามแกนที่สไลด์กำกับไว้: แกนนอนคือ \(d\) (degree of polynomial) แกนตั้งคือ \(J\). เส้น \(J_{\text{train}}\) ลดลงเรื่อย ๆ อย่างเดียวเมื่อ \(d\) เพิ่ม (โมเดลยิ่งยืดหยุ่นยิ่งแนบข้อมูลฝึกได้ดี) ขณะที่เส้น \(J_{cv}\) เป็นรูปตัว U — ลดลงก่อนแล้วกลับเชิดขึ้น. ที่ \(d\) น้อย (เช่น \(h=\theta_0+\theta_1x\)) เส้นทั้งสองสูงและอยู่ใกล้กัน = high bias ตามกรอบซ้ายที่สไลด์ตีไว้; ที่ \(d\) มาก (เช่นถึง \(x^4\)) \(J_{\text{train}}\) ต่ำเตี้ยแต่ \(J_{cv}\) พุ่งสูง = high variance ตามกรอบขวา. จุดที่ดีที่สุดคือก้นตัว U ซึ่งสไลด์ลากเส้นประแนวตั้งกำกับไว้. หมายเหตุปิดท้ายที่ออกสอบได้: "note that bias and variance are inversely related to each other. (ideal solution – low bias & low variance)" — สวนทางกัน การลดตัวหนึ่งมักเพิ่มอีกตัว จึงต้องหาจุดสมดุลแทนที่จะไล่กดตัวใดตัวหนึ่งจนสุด.

10A. แก้ Underfitting: เพิ่มความจุให้โมเดล

เมื่อวินิจฉัยได้ว่าเป็น high bias สไลด์ให้วิธีแก้สี่ข้อซึ่งทุกข้อมีแก่นเดียวกันคือ ทำให้โมเดลยืดหยุ่นขึ้น:

• Increase a number of features — "more information to learn from, leading to better predictions" เช่นจากเดิมใช้แค่ขนาดบ้าน เพิ่มจำนวนห้องน้ำ ปีที่สร้าง ทำเล เข้าไปด้วย โมเดลก็มีข้อมูลให้แยกแยะมากขึ้น
• Add relevant features — "more representative of the problem helps the model improve its performance" คำสำคัญคือ relevant: การเพิ่ม feature ที่ไม่เกี่ยวข้อง เช่น เลขที่บ้าน ไม่ได้ช่วยและยังเพิ่มความเสี่ยง overfit
• Increase higher degree of features — "raising existing features to higher degrees allows the model to capture more complex patterns in the data (such as in the case of linear and logistic regression)" คือเพิ่ม \(x^2, x^3\) เข้าไปในสูตรเดิม ซึ่งเราเห็นผลของมันแล้วในหน้า 43 ที่ \(x^2\) เปลี่ยนเส้นตรงเป็นวงกลม และในหน้า 55 ที่การเพิ่ม \(d\) ดึง \(J_{\text{train}}\) ลง
• Decrease regularization parameter — (สไลด์เขียนว่า explain later ซึ่งคือหัวข้อ 11) ค่า \(\lambda\) ทำหน้าที่ "กดโมเดลให้เรียบ" ดังนั้นตอน underfit ต้องผ่อนมันลง

วิธีสังเกตว่าจำถูกหรือไม่: สามข้อแรกคือการ เติม (เพิ่มจำนวน, เพิ่มความเกี่ยวข้อง, เพิ่มกำลัง) และข้อสุดท้ายคือการ ผ่อน สิ่งที่กดอยู่ — ทั้งหมดเดินไปทางเดียวกันคือขยับ \(d\) ไปทางขวาบนกราฟหน้า 55. ที่ต้องระวังคือ "เพิ่มข้อมูล (more examples)" ไม่ได้ อยู่ในรายการนี้ ซึ่งหน้า 58 จะอธิบายว่าทำไม.

11. Regularization: บีบ θ ให้เล็กโดยไม่ทิ้ง feature

สไลด์ให้สองทางเลือกในการแก้ overfitting. ทางแรกคือ Reduce a number of features, select only relevant features, or decrease degree of polynomial — ตรงข้ามกับสี่ข้อของหัวข้อ 10A ทุกข้อ แต่มีต้นทุนคือ เราทิ้งข้อมูลไปเลย: ถ้าตัด feature "จำนวนห้องน้ำ" ทิ้ง ต่อให้มันช่วยได้นิดหน่อยก็จะไม่มีวันได้ใช้อีก. ทางที่สองคือ Regularization ซึ่งอาจารย์อธิบายว่า Keep all features (each contributes a bit to predict output) แต่ constrains or regularizes พารามิเตอร์ให้มีค่าเล็ก ("many cases towards zero but not zero"). สังเกตวงเล็บนั้นให้ดี — เข้าใกล้ศูนย์แต่ไม่เป็นศูนย์ คือความต่างที่ข้อสอบชอบถาม เพราะถ้าเป็นศูนย์จริงก็เท่ากับตัด feature ทิ้งซึ่งเป็นวิธีแรก.

สไลด์ระบุว่ามีสองตระกูลคือ L1 (lasso) และ L2 (ridge regularization) แล้วเลือกอธิบาย L2 เพราะ "more widely used" โดยเพิ่มเทอม \(\lambda\sum_{j=1}^{n}\theta_j^2\) เข้าไปใน cost function ได้เป็น

cost เดิม + ค่าปรับที่ยิ่ง \(\theta\) ใหญ่ยิ่งแพง — โมเดลจึง "ประหยัด" ไม่ให้ \(\theta\) พองเพื่อไล่ตาม noise

สองรายละเอียดที่ต้องสังเกตจากสูตรบนสไลด์: ผลรวมเริ่มที่ \(j=1\) ไม่ใช่ \(j=0\) แปลว่า ไม่ลงโทษ \(\theta_0\) (เพราะ \(\theta_0\) แค่เลื่อนเส้นขึ้นลง ไม่ได้ทำให้เส้นหยัก) และตัวคูณคือ \(\lambda/m\) ตามที่เขียนอยู่ในกรอบของสไลด์.

ท้ายสไลด์เขียนไว้สั้น ๆ ว่า "if \(\lambda\) is set to be too large \(h_\theta(x) \approx \theta_0\)" — ตรวจด้วยเหตุผลได้ทันที: ถ้า \(\lambda\) ใหญ่มาก เทอมค่าปรับจะครองค่า cost ทั้งหมด วิธีลด cost ที่ง่ายที่สุดคือกด \(\theta_1,\dots,\theta_n\) ให้เข้าใกล้ 0 ทุกตัว เหลือแต่ \(\theta_0\) ⇒ \(h_\theta(x)\approx\theta_0\) คือเส้นแบนราบที่ทำนายค่าเดียวกันหมดไม่ว่าจะป้อน \(x\) อะไรเข้าไป ซึ่งก็คือ underfitting / high bias นั่นเอง. ดังนั้น \(\lambda\) จึงเป็น hyperparameter ที่ต้องหาจุดสมดุลด้วย cross-validation เหมือนการเลือก degree ในหัวข้อ 9. (Lesson 3 §7 และ Lesson 4 §6 ใช้แนวคิดเดียวกัน; Keras เรียกว่า l2(λ) ใน Lesson 5.)

ประโยคเดียวของหน้านี้คือ More examples does help in high variance case! (not help much in high bias case) และสไลด์พิสูจน์ด้วยสองคู่ภาพที่ใช้สมการกำกับไว้ชัด. คู่ซ้ายใช้ \(h_\theta(x)=\theta_0+\theta_1x\): ตอนมีข้อมูลไม่กี่จุด เส้นตรงก็พลาดอยู่แล้ว และตอนเพิ่มข้อมูลเป็นสิบกว่าจุด เส้นตรงก็ยังพลาดเท่าเดิม — เพราะข้อจำกัดอยู่ที่ตัวสมการซึ่งโค้งไม่ได้ ไม่ใช่ที่ปริมาณข้อมูล เติมข้อมูลไปก็ไม่ช่วย. คู่ขวาใช้ \(h_\theta(x)=\theta_0+\theta_1x+\dots+\theta_{50}x^{50}\): ตอนมีข้อมูลน้อย เส้นแดงสามารถบิดตัวมุดขึ้นลงอย่างบ้าคลั่งผ่านทุกจุดได้ตามใจ เพราะระหว่างจุดว่าง ๆ ไม่มีอะไรบังคับมัน; พอเติมข้อมูลเข้าไปจนแน่น เส้นแดงถูกจุดข้อมูลบีบจากทุกทิศจนแทบกลายเป็นเส้นเรียบ — พลังพิสดารของ degree 50 ถูก "ขังไว้" ด้วยข้อมูลนั่นเอง.

สรุปเป็นหลักการที่ใช้ตัดสินใจในงานจริง: ถ้าวินิจฉัยได้ว่าเป็น high variance การลงทุนเก็บข้อมูลเพิ่มคุ้มค่า; แต่ถ้าเป็น high bias การเก็บข้อมูลเพิ่มคือการเสียเงินเปล่า ต้องไปเพิ่มความจุของโมเดลตามหัวข้อ 10A แทน. นี่คือเหตุผลที่ต้องวินิจฉัยด้วย \(J_{\text{train}}\) กับ \(J_{cv}\) ก่อนลงมือแก้เสมอ.

11A. Parameter vs Hyperparameter: ใครเรียนเอง ใครต้องเราตั้ง

หน้านี้แยกคำสองคำที่ถูกใช้สลับกันจนสับสนบ่อยที่สุดในวิชา และเป็นหน้าที่อาจารย์ทำสีไว้แน่นที่สุดหน้าหนึ่ง. หัวข้อคือ Parameter vs Hyperparameter · Model parameters โดยนิยามฝั่งแรกว่า model parameters เป็น "properties of the model that perform predictions" ที่ถูก learned during the training process จาก training data และถูกปรับให้ minimize training error โดย "they are not provided by the machine learning practitioners".

ฝั่งที่สอง Model hyperparameters เป็น "external configurations that govern the ML algorithm training process" ที่ผู้ทำโมเดลเป็นคนกำหนด ก่อน เริ่มเทรน และสไลด์ย้ำว่า "they can't be learned from the training data" แต่ต้อง tuned for a given machine learning task ด้วยการลองซ้ำ ๆ แบบ iterative. สไลด์ยกตัวอย่างไว้ตรง ๆ ว่า Examples ของ model hyperparameters ได้แก่ regularization parameter (\(\lambda\) จากหัวข้อ 11), degree of polynomial (\(d\) จากหัวข้อ 10), learning rate (\(\alpha\) จากหัวข้อ 3) ฯลฯ และวงเล็บปิดท้ายว่า "(coefficients and intercept are parameters)" — คือ \(\theta_1,\dots,\theta_n\) (สัมประสิทธิ์) และ \(\theta_0\) (จุดตัดแกน) เป็น parameter.

ลองทดสอบความเข้าใจด้วยคำถามเดียว: "ถ้าลืมตั้งค่านี้ โปรแกรมจะรันได้ไหม?" — \(\alpha\) ถ้าไม่ตั้งก็เริ่มเทรนไม่ได้เลย (hyperparameter) ส่วน \(\theta_1\) ไม่ต้องตั้งเพราะเดี๋ยวโปรแกรมหาเอง (parameter). อีกวิธีคือถามว่า "gradient descent ปรับตัวนี้หรือไม่" — สูตร \(\theta_j := \theta_j - \alpha\,\partial J/\partial\theta_j\) ปรับเฉพาะ \(\theta\) ส่วน \(\alpha\) ปรากฏอยู่ในสูตรแต่ไม่เคยถูกสูตรนี้แตะเลย.

ย่อหน้าสุดท้ายของสไลด์นิยามขั้นตอน model tuning ว่าเป็นการเทรนโมเดลโดยใช้ a set of hyperparameters เพื่อให้ได้ optimal performance ตามวัตถุประสงค์ที่ตั้งไว้ในขั้นแรกของกระบวนการพัฒนา ML พร้อมเตือนตามตรงว่า "this step can be tedious, repetitive, and time-consuming as it requires experimenting with different ML algorithms or hyperparameter sets". เชื่อมกลับไปหน้า 53 ได้พอดี: ขั้นตอน "repeat step 1 for each set of hyperparameters" ของ cross validation ก็คือ model tuning ที่ว่านี้ และ Lesson 6 จะสอนวิธีทำให้มันอัตโนมัติด้วย Keras Tuner.

12. Unsupervised Learning: K-means Clustering

หน้าสุดท้ายของ lecture กลับมาที่ฝั่งที่ไม่มีเฉลย: Given a set of unlabeled points and want to discover interesting patterns in this dataset โดยมีคำอธิบายกำกับสองบรรทัดว่า "no correct answers - no target to learn" และ "descriptive model, not trying to predict outputs". เทียบกับภาพสองอันบนสไลด์: อันซ้ายคือข้อมูล \(X_1, X_2\) ที่ยังเป็นสีเดียวกันหมด (ไม่มีป้าย) อันขวาคือข้อมูลชุดเดียวกันหลังจัดกลุ่มแล้วเป็น cluster1, cluster2, cluster3 — สังเกตว่า "สี" ในภาพขวาไม่ได้มาจากเฉลยใด ๆ แต่เป็นสิ่งที่อัลกอริทึมสร้างขึ้นเองจากการที่จุดเหล่านั้นอยู่ใกล้กัน.

อัลกอริทึมที่สไลด์เขียนเป็นซูโดโค้ดอ่านได้ดังนี้ — เริ่มจาก Randomly initialize \(K\) cluster centroids \(\mu_1,\mu_2,\mu_3,\dots,\mu_k \in \mathbb{R}^n\) แล้ววนสองขั้นตอนนี้สลับกัน:

1. Assign — for \(i = 1\) to \(m\): ให้ \(c^{(i)} :=\) index of cluster centroid (from 1 to \(K\)) closest to \(x^{(i)}\) คือให้แต่ละจุดข้อมูลสังกัด centroid ที่ใกล้ที่สุด
2. Update — for \(k = 1\) to \(K\): ให้ \(\mu_k :=\) average of points assigned to cluster \(k\) คือย้าย centroid ไปที่ค่าเฉลี่ยของสมาชิกของมัน \(\mu_k = \frac{1}{|C_k|}\sum_{x\in C_k} x\)

และเงื่อนไขหยุดสองข้อที่อาจารย์ทำสีไว้ท้ายสุด: iterate until the cluster assignments stop changing หรือ reach max iterations. เงื่อนไขแรกคือการลู่เข้าจริง ส่วนเงื่อนไขที่สองเป็นตัวกันไม่ให้วนไม่รู้จบ — ข้อสอบชอบถามว่า "K-means หยุดเมื่อไร" โดยมีตัวเลือกลวงว่า "เมื่อ cost เป็นศูนย์" หรือ "เมื่อ gradient เป็นศูนย์" ซึ่งไม่ใช่ทั้งคู่ เพราะ K-means ไม่มีการใช้ gradient descent เลย.

13. เชื่อมกับ Lesson ถัดไป

ทุกสูตรในบทนี้ — cost function, gradient descent, sigmoid, softmax, regularization, bias/variance — จะกลับมาใน Lesson 2–6 แค่เปลี่ยนจาก "1 node" เป็น "หลาย node เรียงเป็น layer". ถ้าสูตร \(\theta_j := \theta_j - \alpha\,\partial J/\partial\theta_j\) และตัวอย่างคำนวณในบทนี้แม่นแล้ว บทต่อ ๆ ไปคือการใส่ subscript/superscript เพิ่มเข้าไปในสูตรเดิม ไม่ใช่การเรียนหลักการใหม่.

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

ไล่ทุกหน้าของ Lecture1.pdf ตั้งแต่ 1 ถึง 60 — หน้าที่มี ✓ ถูกสอนไว้ในหัวข้อที่ลิงก์ไว้ (คลิกเพื่อกระโดดไป) ส่วนที่เหลือคือหน้าปก หน้าอ้างอิงหนังสือ และหน้าคั่นบท ซึ่งไม่มีเนื้อหาให้สอน.

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