ทำไมต้องสร้างจากศูนย์ — เปิดฝากระโปรง model ที่ agent เรียกใช้

เจ็ดคอร์สที่ผ่านมาของสาย AI-engineering (#15 first-ai-agent → #16 context-engineering → #17 agent-harness-loop → #12 agent-as-context → #13 evals → #14 mcp → #18 guardrails) คุณสร้างของจริงขึ้นมาเยอะมาก — agent ที่เรียก tool, context layer ที่ retrieve เอกสาร, loop ที่ orchestrate หลายขั้น, eval harness, MCP server, ชั้น guardrail กันการโจมตี แต่มีสิ่งหนึ่งที่ทุกคอร์สเหล่านั้น ไม่เคยแตะ: ตัว model เอง ทุกครั้งที่คุณเรียก client.messages.create(...) มีเครื่องจักรก้อนหนึ่งหมุนอยู่หลัง API — คุณป้อน token เข้าไป มันคาย token ถัดไปกลับมา คุณ ใช้ มันมาตลอด แต่ไม่เคยเห็นข้างในว่ามันทำงานยังไง

คอร์สนี้เปิดฝากระโปรงก้อนนั้น เราจะ สร้าง model ขึ้นมาเองด้วยมือ ตั้งแต่ neuron ตัวเดียวจน — 8 บทต่อมา — ประกอบเป็น Transformer ตัวจิ๋วที่รันบน CPU เครื่องเดียวได้ ไม่ใช่เพื่อให้ได้ LLM ไปแข่งกับใคร แต่เพื่อให้คุณ เห็นทั้งกอง ว่าอะไรหมุนอยู่ข้างในตอน forward กับ backward

📦 kaen-nn-from-scratch

code ลงมือของคอร์สนี้อยู่ใน repo kaen-nn-from-scratch (code ตัวอย่างกำลังจัดทำ) — pure Python (ไม่มี framework) ตลอดบท2–5 แล้ว graduate ไป PyTorch (pin version + วันที่ดึง) ในบท6–8 บทนี้เป็นบทวางกรอบความคิด — ยัง ไม่มี code รันได้ code จริงเริ่มที่บท2 (สร้าง autograd engine ตัวแรกด้วยมือ) บทนี้ตั้ง precedent ของ honesty spine กับ 🔗 callout อ้างอิงต้นทางไว้ให้ทุกบทหลังจากนี้เดินตาม

USE vs BUILD — เส้นแบ่งหลักของคอร์สนี้

ถ้าจะจำคอร์สนี้ด้วยประโยคเดียว ให้จำเส้นแบ่งนี้ — และมันคือเส้นที่กันไม่ให้คอร์สนี้ไปทับกับ 7 คอร์สก่อนหน้า:

“คอร์ส #15-#18 ทั้งกอง ‘ใช้’ model ผ่าน API/SDK — คอร์สนี้ ‘สร้าง’ model ตัวนั้นขึ้นมาเองตั้งแต่ neuron; และในขณะที่ #16 context-engineering สร้าง embedding ในฐานะ retrieval tool (พร้อมหมายเหตุว่า Claude ไม่มี embeddings endpoint), ที่นี่เราสร้าง embedding ‘ด้วยมือ’ ใน บท4 เพื่อเห็นว่ามันเป็นแค่ตาราง weight ที่ gradient descent ขยับ — ไม่ใช่เพื่อเอาไปค้นเอกสาร”

นี่คือความต่างที่คมที่สุด: #16 มอง embedding เป็น เครื่องมือ (tool) — เวกเตอร์ที่เอาไปวัดความใกล้เพื่อ retrieve เอกสารเข้า context ส่วนที่นี่เรามอง embedding เป็น วัตถุ (object) — ตาราง weight ที่เริ่มจากตัวเลขสุ่ม แล้ว gradient descent ค่อยๆ ขยับมันระหว่างเทรน เป้าหมายคนละเรื่องกันโดยสิ้นเชิง คอร์สนี้จะ ไม่ สอน RAG/retrieval ซ้ำ (นั่นของ #16), ไม่สอน eval harness ซ้ำ (#13), ไม่สอน prompt-guardrail ซ้ำ (#18) — เราโฟกัสที่เรื่องเดียว: อะไรหมุนอยู่ข้างในตอน forward + backward

บันไดสี่ขั้นที่คอร์สนี้จะไต่ขึ้น

ทั้งคอร์สคือการไต่บันไดสี่ขั้นเป็นเส้นเดียวต่อเนื่อง แต่ละขั้นเป็นวัตถุดิบของขั้นถัดไป:

Neuron — หน่วยคำนวณตัวจิ๋วที่สุด: เอา input มาคูณ weight บวก bias แล้วบีบผ่าน activation function หนึ่งครั้ง นี่คืออะตอมของทั้งกอง
Neural Network — เอา neuron หลายตัวมาต่อกันเป็นชั้นๆ ให้ข้อมูลไหลผ่านจาก input ไป output
network ที่ “ลึก” (Deep Learning) — ซ้อนชั้นเหล่านั้นหลายชั้นจนมันเรียนของซับซ้อนได้เองจากข้อมูล โดยไม่ต้องเขียนกฎเอง คำว่า “deep” ก็คือ “หลายชั้น” นี่แหละ
model ที่ agent ของคุณเรียกใช้ — transformer ที่ซ้อน self-attention เป็นชั้นๆ คือโครงที่ LLM จริงหลัง API ใช้ ขั้นสุดท้ายของบันไดคือจุดที่วนกลับมาบรรจบกับสิ่งที่ #15-#18 เรียกใช้ทุกวัน

flowchart TB
  N["neuron<br/>input × weight + bias → activation<br/>(อะตอมตัวจิ๋ว)"]
  NN["neural network<br/>เอา neuron มาต่อเป็นชั้น ๆ"]
  DN["deep network<br/>ซ้อนหลายชั้นให้ 'ลึก'<br/>เรียนของซับซ้อนเองจากข้อมูล"]
  M["model ที่ agent ของคุณเรียกใช้<br/>transformer / LLM หลัง API"]
  N -->|"บท2–3"| NN
  NN -->|"บท4–5"| DN
  DN -->|"บท6–8"| M

  classDef base fill:#fde68a,stroke:#92400e,color:#451a03;
  classDef top fill:#7c2d12,stroke:#431407,color:#fed7aa;
  class N,NN,DN base;
  class M top;

คำบรรยายภาพ: บันไดสี่ขั้นที่คอร์สนี้ไต่ขึ้นทีละขั้น — เริ่มจาก neuron ตัวเดียว (input คูณ weight บวก bias แล้วผ่าน activation) เอามาต่อกันเป็น neural network ซ้อนให้ลึกจนกลายเป็น deep network แล้วจบที่ transformer ซึ่งเป็นโครงเดียวกับ model ที่ agent ของคุณใน #15-#18 เรียกผ่าน API ป้ายบนเส้นบอกช่วงบทที่พาไต่แต่ละขั้น ทุกขั้นเป็นวัตถุดิบของขั้นถัดไป ไม่มีขั้นไหนกระโดดข้าม

เส้นความซื่อสัตย์สี่เส้นของคอร์สนี้

ก่อนลงบทแรกที่มี code ปักความจริงสี่ข้อนี้ไว้ — ทุกบทลงมือจะย้ำข้อที่เกี่ยวข้องซ้ำ บทนี้กับบท8 (บทปิด) แบกครบทั้งสี่เส้น สองเส้นที่ต้องเน้นก่อนคือ B กับ C

เส้น B — สร้างเพื่อเข้าใจ ไม่ใช่เพื่อ deploy

“เราสร้างเพื่อเข้าใจ ไม่ใช่เพื่อ deploy — micrograd กับ nano-GPT ตัวจิ๋วในคอร์สนี้รันบน CPU เครื่องเดียวได้; แต่ LLM จริงกินทั้ง GPU cluster, ข้อมูลระดับเทระ, เวลาเป็นเดือน — สเกลที่คอร์สนี้ ‘ไม่’ จำลอง”

แปลว่า: คุณจะได้ mental model ที่ถูกต้องของ forward → backward → update; คุณจะ ไม่ ได้ training stack ที่ใช้งานจริง (data pipeline, distributed, mixed-precision, checkpointing) — และนั่นคือ design ไม่ใช่ ช่องโหว่

เส้น C — นี่คือเครื่องที่ agent ของคุณเรียกใช้ (สะพาน ไม่ใช่ prerequisite)

“backprop ตัวเดียวกันนี้แหละที่หมุนอยู่ข้างใน model ที่ agent ของคุณใน #15-#18 เรียกผ่าน API — เข้าใจมันแล้วจะเห็นทั้งกองตั้งแต่ neuron ยัน tool-call; แต่พูดตรงๆ: ไม่รู้ backprop ก็สร้าง agent ได้”

แปลว่า: คอร์สนี้เป็น สะพานความเข้าใจ ไม่ใช่ prerequisite ของ #15-#18 คุณสร้าง agent ตัวแรกได้โดยไม่รู้ Backpropagation เลย — มาคอร์สนี้เพื่อ เห็นทั้งกอง ไม่ใช่เพราะจำเป็นต้องรู้ก่อน

เส้น A — ของสดใช้ repo, ของนิ่งใช้ตำรา

“ของสดใช้ repo, ของนิ่งใช้ตำรา — code ของ Karpathy คือ repo ที่ยังมีชีวิต เราจึงอ้างด้วย commit SHA + วันที่ดึง ไม่ใช่เลขรุ่น; ส่วนคณิตที่ไม่เน่าเราอ้าง Goodfellow-Bengio-Courville (MIT Press, 2016)”

แปลว่า: code สด (Karpathy) รันได้วันนี้แต่ upstream อาจขยับใต้เท้าคุณพรุ่งนี้ — จึง pin ด้วย SHA; ส่วนคณิตในตำราปี 2016 นิ่งและตรวจได้ แต่ “เก่า” ในเรื่อง practice สมัยใหม่ — เราจึงอ้างมันเฉพาะคณิตที่ไม่เน่า และติดป้าย “stale-on-modern-practice” ทุกจุดที่มันแตะของหลังปี 2016

เส้น D — คณิตเป็นพื้นให้ยืน ไม่ใช่กำแพงกั้นทาง

“เราสอน ‘สัญชาตญาณ’ ของ gradient กับ chain rule พอให้ code มีความหมาย ไม่ใช่พิสูจน์ทฤษฎีบท — อยากลึกเชิงพิสูจน์ เปิด Goodfellow บทที่อ้างไว้; คณิตตรงนี้เป็นพื้นให้ยืน ไม่ใช่กำแพงกั้นทาง”

แปลว่า: เราเลือก “เข้าใจเร็ว” แทน “พิสูจน์ครบ”; ความเข้มงวดเชิงพิสูจน์ถูก out-source ไปที่ Goodfellow-Bengio-Courville (Deep Learning, MIT Press, 2016) พร้อม pointer บท/หัวข้อทุกครั้ง — ตำราคณิตที่ “นิ่ง” ที่เราอ้างเฉพาะคณิตไม่เน่า และติดป้าย stale ทุกที่ที่มันแตะ practice หลังปี 2016

ขอบเขต: อะไรอยู่ใน อะไรอยู่นอก — และทำไม

อยู่ใน (IN): เส้นเดียวต่อเนื่อง — neuron → autograd/backprop (micrograd) → bigram language model → MLP + embedding → training internals (init/BatchNorm) → PyTorch → self-attention/transformer → nano-GPT capstone รวม 8 บท ทุกบทเป็นวัตถุดิบของบทถัดไป ไม่มีบทไหนลอยเดี่ยว

อยู่นอก (OUT): ห้าเรื่องนี้เราตัดออกอย่างจงใจ — และบอกเหตุผลตรงๆ เพื่อไม่ให้ใครอนุมานว่าคอร์สครอบคลุมมัน:

นอกขอบเขต	ทำไมถึงตัดออก
CNN / งาน computer vision	inductive bias คนละแบบ — convolution ออกแบบมาสำหรับโครงสร้างเชิงพื้นที่ของภาพ ไม่ใช่การทาย token ถัดไปของภาษา คอร์สนี้เดินสาย language model เส้นเดียว
RL / RLHF	reward signal ≠ next-token NLL; มันเป็นชั้นที่มา หลัง pretraining (จูนพฤติกรรมด้วยรางวัล) คนละกลไกกับที่คอร์สนี้สอน
การเทรนสเกล GPU / distributed training	ขัดกับ เส้น B ตรงๆ — เราสร้างเพื่อเข้าใจบน CPU เครื่องเดียว ไม่ใช่จำลองสเกลจริง (GPU cluster / ข้อมูลระดับเทระ / เวลาเป็นเดือน)
MLOps / serving / deployment	ทับกับคอร์ส #19 production-observability (ชั้น OPERATE) — เรื่อง deploy/สังเกตการณ์เป็นของคอร์สนั้น ไม่ derive ซ้ำที่นี่
fine-tune LLM จริง / LoRA	ต้องมี pretrained weights + สเกลที่คอร์สนี้ไม่แตะ (ดู เส้น B) — เราสร้าง model จิ๋วจากศูนย์ ไม่ได้จูน model ใหญ่ที่มีคนเทรนมาแล้ว

เกร็ดประวัติศาสตร์ (บรรทัดเดียว)

เปเปอร์ Rumelhart–Hinton–Williams ปี 1986 (S10) ทำให้ backprop เป็นที่นิยม ในวงการ neural network — แต่ ไม่ได้ เป็นคนคิด reverse-mode automatic differentiation ขึ้นมาเอง (Linnainmaa 1970 และ Werbos 1974 มาก่อน) เรื่องนี้เป็นแค่เกร็ด ไม่ใช่สาระที่ต้องท่อง แต่มันเตือนว่าไอเดียหลักของทั้งคอร์ส — การไล่ chain rule ย้อนกลับ — เก่ากว่าที่คนส่วนใหญ่คิด

สรุปก่อนไปต่อ

7 คอร์สก่อนหน้าให้คุณ ใช้ model ผ่าน API/SDK จนคล่อง — บทนี้วางกรอบว่าทำไมเราจะ สร้าง มันเองตั้งแต่ neuron: USE vs BUILD คือเส้นแบ่งหลัก (และ embedding-เป็น-วัตถุ ที่นี่ ต่างจาก embedding-เป็น-เครื่องมือ ที่ #16); เส้นความซื่อสัตย์สี่เส้น — โดยเฉพาะ B (สร้างเพื่อเข้าใจ ไม่ใช่ deploy) และ C (เป็นสะพาน ไม่ใช่ prerequisite — ไม่รู้ backprop ก็สร้าง agent ได้) — จะกำกับทุกบทที่เหลือ; ขอบเขตชัดว่า CNN/RL/GPU-scale/MLOps/fine-tuning อยู่นอก และเราบอกเหตุผลทุกข้อ บทนี้ยังไม่มี code รันได้ — เป็นแผนที่ก่อนออกเดินทาง

บทหน้าเลิกพูดกรอบ — เราจะสร้าง autograd engine ตัวแรกด้วยมือ (micrograd) class Value ตัวจิ๋วที่จำได้ว่าค่าไหนมาจากค่าไหน แล้วไล่ backprop ย้อนกลับเองทั้งหมด นี่คือขั้นแรกของบันไดที่จะพาไปถึง transformer

🔗 อ้างอิงต้นทางของบทนี้

บทนี้อิงต้นทางที่ลงวันที่กำกับ อ่านต่อได้โดยตรง:

Karpathy — Neural Networks: Zero to Hero (course home + prereqs) (S17, เข้าถึง 2026-07-23) — spine ของทั้งคอร์ส; prereq bar (“solid programming (Python), intro-level math”) และเหตุผลว่าทำไม language model เป็นที่เรียน deep learning ที่ดี: “most of what you learn will be immediately transferable”
Karpathy — nn-zero-to-hero (repo + lecture notebooks) (S1, commit 73c3fcc741f0ec104ca850b1fb0df90e7e8d4cde, 2024-02-20; เข้าถึง 2026-07-23) — repo ที่ยังมีชีวิต จึงอ้างด้วย commit SHA + วันที่ดึง ไม่ใช่เลขรุ่น (เส้น A)
Goodfellow, Bengio, Courville — Deep Learning (MIT Press, 2016) (S8) — ตำราคณิตที่ “นิ่ง” ใช้เป็น anchor เฉพาะคณิตที่ไม่เน่า และติดป้าย “stale-on-modern-practice” ทุกจุดที่มันแตะของหลังปี 2016 (เส้น A/D)
Rumelhart, Hinton, Williams — Learning representations by back-propagating errors, Nature 323, 533–536 (1986) (S10) — เปเปอร์ที่ทำให้ backprop เป็นที่นิยม (ไม่ใช่คนคิด reverse-mode autodiff คนแรก)

เช็กความเข้าใจ — บทที่ 1

ข้อ 1 / 3

อะไรคือเส้นแบ่งหลัก (spine) ที่ทำให้คอร์ส #20 นี้ต่างจากคอร์ส #15–#18?

ทำไม​ต้อง​สร้าง​จาก​ศูนย์ — เปิด​ฝากระโปรง model ที่ agent เรียก​ใช้

USE vs BUILD — เส้น​แบ่ง​หลัก​ของ​คอร์ส​นี้

บันได​สี่​ขั้น​ที่​คอร์ส​นี้​จะ​ไต่​ขึ้น

เส้น​ความ​ซื่อสัตย์​สี่​เส้น​ของ​คอร์ส​นี้

ขอบเขต: อะไร​อยู่​ใน อะไร​อยู่​นอก — และ​ทำไม

เกร็ด​ประวัติศาสตร์ (บรรทัด​เดียว)

สรุป​ก่อน​ไป​ต่อ