12/30บทที่ 12 จาก 30

Chain of Thought, RLVR และ Test-Time Compute ที่วัดผลได้

ปัญหาเดิม 24 ข้อ: ถูก 0% ด้วย 1.9 token, ถูก 100% ด้วย 145 token แล้ว self-consistency ซื้อความแม่นยำเดิมของ greedy decoding กลับมา

13 กรกฎาคม 2569อัปเดต 11 กันยายน 2569อ่าน 6 นาที

ในหน้านี้

โจทย์ปัญหาคำสองขั้นตอน 24 ข้อ โมเดลขนาดเล็ก — พารามิเตอร์ครึ่งพันล้าน ตัวเดียวกับใน บทที่ 11 — ถูกถามแต่ละข้อสองครั้ง

ครั้งแรก ขอคำตอบเลย:

TEXT

"...How many bolts are left?  Reply with only the final number, nothing else."

  0 / 24 correct        1.9 tokens per answer

จากนั้น ขอคำตอบอีกครั้ง แต่อนุญาตให้ทำวิธีก่อน:

TEXT

"...How many bolts are left?  Think step by step, then give the final
 number on its own line."

  24 / 24 correct       145.2 tokens per answer

จากศูนย์เป็นร้อยเปอร์เซ็นต์ โมเดลเดิม weights เดิม โจทย์เดิม greedy decoding เดิม ความต่างเพียงอย่างเดียวคือเวอร์ชันที่สองได้รับอนุญาตให้ปล่อย token เพิ่มอีก 143 token ก่อนยืนยันตัวเลข

บทนี้ว่าด้วยช่องว่างนั้น: จริง ๆ แล้วมันคืออะไร ไปได้ไกลแค่ไหน มีต้นทุนเท่าไร และเกิดอะไรขึ้นเมื่อวงการเลิกขอมันใน prompt แล้วเริ่มฝึกมันเข้าไปในโมเดล

โมเดลไม่ได้คิด มันคำนวณนานขึ้น

ลิงก์ไปยังส่วน: โมเดลไม่ได้คิด มันคำนวณนานขึ้น

สิ่งที่ชวนให้พูดคือเวอร์ชันที่สอง “คิดเกี่ยวกับมัน” แต่ควรต้านแรงดึงนั้นไว้ เพราะกลไกทั้งเรียบง่ายกว่าและมีประโยชน์กว่าที่จะรู้

transformer ทำการคำนวณในปริมาณที่ คงที่ ต่อ token ที่สร้างขึ้น หนึ่ง forward pass: ชั้นเดิม เมทริกซ์เดิม จำนวน operations เดิม ไม่ว่าคำถามจะเป็น 2+2 เท่ากับอะไร หรือ พิสูจน์ทฤษฎีบทนี้ ภายในโมเดลไม่มีปุ่มหมุนสำหรับ “ข้อนี้พยายามให้หนักขึ้น”

ดังนั้นเมื่อโมเดลถูกขอให้ตอบทันที การคำนวณทั้งหมดที่มีให้มันคือหนึ่ง forward pass ปริมาณกลางทางทุกอย่างต้องพอดีอยู่ใน activations ของ pass เดียวนั้น และอะไรที่คำนวณตรงนั้นไม่ได้ มันก็จะคำนวณไม่ได้

การปล่อย token เปลี่ยนเรื่องนี้ และเปลี่ยนในสองทางที่ควรแยกกันให้ชัด:

การคำนวณมากขึ้น token ที่สร้างขึ้นแต่ละตัวคือ forward pass เต็มอีกหนึ่งครั้ง การทำงาน 145 token คือเลขคณิตมากกว่าการตอบทันที 145 เท่า
หน่วยความจำที่ถูกทำให้อยู่ภายนอก token ถูกเขียนลงใน context ดังนั้น pass ถัดไปจึงอ่านมันได้ 5 × 13 = 65 กลายเป็น ข้อเท็จจริงในอินพุต ไม่ใช่ค่าที่โมเดลต้องเก็บไว้ใน activation แล้วพกต่อไป โมเดลกำลังใช้เอาต์พุตของตัวเองเป็น scratchpad

ข้อที่สองคือสิ่งที่คนมักพลาด และมันอธิบายว่าทำไมการทำงานต้องถูก เขียนออกมา จึงจะช่วยได้ โมเดลที่ถูกขอให้ “คิดเงียบ ๆ แล้วค่อยตอบ” ไม่มีที่ให้วางความคิดนั้น

ทั้งหมดนี้ไม่ต้องอาศัยอะไรลี้ลับ และมันให้คำทำนายที่ชัด: chain of thought ควรช่วยได้มากที่สุดกับปัญหาที่มีโครงสร้างแบบ ลำดับต่อเนื่อง — ขั้นที่สองต้องใช้ผลจากขั้นที่หนึ่ง — และช่วยได้น้อยที่สุดกับปัญหาที่เป็นการ lookup ครั้งเดียว นั่นคือสิ่งที่วรรณกรรมพบพอดี และเป็นเหตุผลว่าทำไม “think step by step” จึงไม่ช่วยอะไรกับ เมืองหลวงของฝรั่งเศสคืออะไร

Chain of thought ในฐานะเทคนิค prompting

ลิงก์ไปยังส่วน: Chain of thought ในฐานะเทคนิค prompting

เทคนิคนี้มาถึงในปี 2022 เป็นสองส่วน Wei และคณะ แสดงให้เห็นว่าการใส่ตัวอย่างที่ทำแล้วไว้ใน prompt — ตัวอย่างสาธิตที่คำตอบมี reasoning นำหน้า — ให้ผลดีขึ้นมากบน benchmark เลขคณิตและสามัญสำนึก¹ จากนั้น Kojima และคณะ แสดงสิ่งที่แปลกกว่า: คุณไม่ต้องใช้ตัวอย่างก็ได้ การเติม “Let's think step by step” ต่อท้าย zero-shot prompt เก็บผลดีส่วนใหญ่แบบเดียวกันได้²

ผลลัพธ์ที่สองคือสิ่งที่บอกว่าเกิดอะไรขึ้น ถ้าวลีวิเศษปลดล็อกพฤติกรรมได้ แปลว่าพฤติกรรมนั้นมีอยู่ในโมเดลแล้ว — pretraining เต็มไปด้วยวิธีทำที่แสดงขั้นตอน และวลีนั้นเป็นตัวชี้ไปยังบริเวณนั้นของ distribution Chain of thought ไม่ได้สอนอะไรโมเดล มัน เลือก สิ่งที่โมเดลมีอยู่แล้ว

กรอบคิดนี้ยังทำนายความล้าสมัยในท้ายที่สุดของเทคนิคนี้ด้วย ซึ่งเราจะกลับมาพูดถึงตอนท้ายบท

Self-consistency และผลลัพธ์ที่ทำให้ผมประหลาดใจ

ลิงก์ไปยังส่วน: Self-consistency และผลลัพธ์ที่ทำให้ผมประหลาดใจ

ก้าวถัดไปที่ชัดเจน: ถ้า chain ของ reasoning หนึ่งเส้นอาจผิด ก็ sample หลายเส้นแล้วใช้คำตอบเสียงข้างมาก นั่นคือ self-consistency³ มันคือการใช้จ่ายที่มากขึ้นอย่างเคร่งครัด — generation เต็ม $n$ ครั้งแทนที่จะเป็นครั้งเดียว — และสัญชาตญาณคือคำตอบผิดจะกระจาย ส่วนคำตอบถูกจะเห็นตรงกัน

วัดกับโจทย์เดิม 16 ข้อ sampling ที่ temperature 0.8 ใช้เสียงข้างมากจาก chain จำนวน $n$ :

$n$	accuracy	cumulative tokens	tokens per problem
1	81 %	2,952	185
2	81 %	5,618	351
3	100 %	8,417	526
4	100 %	11,103	694
5	100 %	13,933	871

โจทย์ 16 ข้อเป็นตัวส่วนที่เล็ก และกฎของ บทที่ 4 ใช้กับตารางนี้ได้ไม่ต่างจากตารางอื่น 13 จาก 16 คือ 81 % พร้อมช่วง Wilson 95 % ที่ [57, 93]; 16 จาก 16 คือ 100 % พร้อม [81, 100] ช่วงเหล่านั้นทับซ้อนกัน ให้อ่านรูปร่างของโค้ง ซึ่งคือข้อค้นพบ อย่าอ่านขั้นที่แน่นอนว่ามันแบนตรงไหน เพราะโจทย์ 16 ข้อระบุตำแหน่งนั้นไม่ได้

มีสองอย่างในตารางนั้น และอย่างที่สองไม่ใช่สิ่งที่ผมคาดไว้

โค้งแบนที่ $n = 3$ พอถึง sample ที่สาม accuracy แตะเพดานแล้ว และ sample อีกสองอันที่เหลือไม่ได้ซื้ออะไรเพิ่ม แต่มีต้นทุนอันละ 172 token รวมกัน 345 นี่คือรูปร่างของโค้ง self-consistency ทุกเส้นที่รายงานในวรรณกรรม และมันเกิดเร็วกว่ากรอบคิดแบบ “sample มากขึ้นยิ่งดีกว่า” มาก

และ greedy decoding ก็อยู่ที่ 100 % อยู่แล้ว กลับไปดูต้นบท: chain เดียว ไม่ sampling, 145 token, 24/24 การ sampling ที่ temperature 0.8 ทำให้ accuracy ลดลง เหลือ 81 % และ self-consistency ต้องใช้ generation สามครั้งเพื่อไต่กลับไปยังจุดที่ pass แบบ greedy ครั้งเดียวมีอยู่แล้ว — ด้วยจำนวน token 3.6 เท่า หรือหกเท่าหากคุณรัน sweep ไปถึงห้าโดยไม่รู้ว่ามันจะแบนตรงไหน

นี่ไม่ใช่ข้อโต้แย้งต่อ self-consistency แต่มันคือคำอธิบายที่แม่นยำว่าสิ่งนี้ทำอะไร: temperature ซื้อความหลากหลายด้วยการฉีดข้อผิดพลาดเข้าไป และการโหวตก็กำจัดข้อผิดพลาดที่มันเพิ่งฉีดเข้าไปเอง ในปัญหาที่ greedy decoding ล้มเหลว — เมื่อ chain ที่น่าจะเป็นไปได้มากที่สุดเพียงเส้นเดียวนำไปผิดทาง และเส้นที่น่าจะเป็นไปได้น้อยกว่ากลับถูก — การแลกเปลี่ยนนี้คุ้ม และนั่นคือเหตุผลที่เทคนิคนี้มีอยู่ ในปัญหาที่ greedy สำเร็จอยู่แล้ว มันคือวิธีใช้ budget หกเท่าเพื่อกลับมาเสมอตัว

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

Tree of thoughts และต้นทุนเป็นจำนวน call

การทำให้ทั่วไปขึ้นคือการแตกกิ่ง: แทนที่จะ sampling chain อิสระ $n$ เส้น ให้สำรวจ tree ของสถานะ reasoning บางส่วน ประเมินมัน แล้วขยายเส้นที่มีแนวโน้มดี⁴ มันใช้ได้ และเป็นโครงสร้างที่ถูกต้องสำหรับปัญหาที่ต้องใช้ search — puzzle, planning, อะไรก็ตามที่มี backtracking

ต้นทุนคือสิ่งที่ทำให้มันไม่ใช่ค่า default Self-consistency ที่ $n = 5$ คือ generation ห้าครั้ง tree ที่มี breadth $b$ และ depth $d$ มีได้สูงสุด $b^d$ สถานะ และแต่ละสถานะต้องใช้ generation อย่างน้อยหนึ่งครั้งเพื่อขยาย และมักใช้อีกครั้งเพื่อประเมิน ผลลัพธ์ที่ตีพิมพ์ใช้ model call หลายสิบถึงหลายร้อยครั้งสำหรับคำตอบเดียว

นั่นเป็นค่าใช้จ่ายคนละแบบกับ chain ที่ยาวขึ้น chain 900 token คือหนึ่ง request ที่มี latency คาดการณ์ได้ tree 100 call คือ round trip 100 ครั้ง โอกาสชน rate limit 100 ครั้ง และ latency ที่เป็นผลรวมของ dependency แบบอนุกรม 100 จุด — ซึ่งเป็นปัญหาของ บทที่ 14 ไม่ใช่ปัญหาเชิงโมเดล

จากการขอ ไปสู่การฝึก

ลิงก์ไปยังส่วน: จากการขอ ไปสู่การฝึก

ทุกอย่างจนถึงตอนนี้เกิดขึ้นตอน prompt time บนโมเดลที่ไม่เคยถูกฝึกมาเพื่อสิ่งนี้โดยเฉพาะ การเปลี่ยนผ่านที่สร้าง reasoning model รุ่นปัจจุบันคือการย้ายมันเข้าไปใน training — และกุญแจที่ทำให้สิ่งนั้นเป็นไปได้แคบกว่าที่ฟังดู

post-training ในบทที่ 11 ต้องใช้ human preferences เพราะคำถามว่า “นี่เป็นคำตอบที่ดีไหม?” ไม่มีคำตอบเชิงโปรแกรม แต่สำหรับคำถามบางประเภท มันมี คำตอบคณิตศาสตร์จะเท่ากับค่าที่ถูกต้องหรือไม่เท่าก็เท่านั้น โค้ดจะผ่าน tests หรือไม่ผ่านก็เท่านั้น proof จะตรวจผ่านหรือไม่ก็เท่านั้น

สำหรับ domain เหล่านั้น คุณแทน reward model ด้วย verifier ได้ และทุกอย่าง downstream ดีขึ้นพร้อมกัน: ไม่ต้องมี annotator, ไม่ต้อง fit Bradley–Terry, ไม่มี reward hacking แบบที่วัดไว้ในบทที่ 11 — เพราะคุณประจบ unit test ไม่ได้ นี่คือ reinforcement learning from verifiable rewards และเป็น setting ที่ GRPO ถูกสร้างมาเพื่อมัน: sample กลุ่มของความพยายามแก้โจทย์เดียวกัน ตรวจแต่ละอัน แล้วใช้ค่าเฉลี่ยคะแนนของกลุ่มเป็น baseline ไม่มี critic ไม่มี annotator ไม่มี reward model มีแค่โปรแกรมที่บอกว่าถูกหรือผิด

Outcome reward ให้คะแนนเฉพาะคำตอบสุดท้าย ถูก — แค่ string comparison — และมีช่องโหว่ชัดเจน: วิธีทำที่ไปถึงตัวเลขถูกด้วย reasoning ผิดได้รับ reward เหมือนกับวิธีที่ถูกต้อง ดังนั้น policy จึงมีอิสระที่จะเรียนรู้เรื่องไร้สาระที่ดูน่าเชื่อแต่บังเอิญไปถึงคำตอบ

Process reward ให้คะแนนแต่ละ ขั้นตอน Lightman และคณะ⁵ สร้าง dataset ของขั้นตอน reasoning ที่มนุษย์ติดป้ายกำกับ 800,000 ขั้น เพื่อฝึกโมเดลที่ทำสิ่งนี้ และแสดงว่ามันทำได้ดีกว่า outcome supervision อย่างมากในคณิตศาสตร์ยาก ต้นทุนอยู่ในชื่อนั่นเอง: มีคนติดป้ายกำกับ 800,000 ขั้นตอน

ผลลัพธ์ที่ปรับกรอบคิดของทั้งวงการมาจาก DeepSeek ช่วงต้นปี 2025⁶ พวกเขานำ base model มาใช้ reinforcement learning with verifiable rewards โดยตรง โดยไม่มี supervised fine-tuning stage มาก่อน — stage ที่บทที่ 11 นำเสนอว่าเป็นรากฐานของทุกอย่าง ถึงอย่างนั้น chain ของ reasoning ที่ยาวก็ เกิดขึ้นเอง พฤติกรรมที่ไม่มีใครฝึกมาก็เกิดขึ้นด้วย: โมเดลเริ่มตรวจสอบขั้นตอนของตัวเองซ้ำ และในข้อความที่ถูกอ้างมากที่สุดของ paper มันพิจารณาแนวทางใหม่เองกลางวิธีทำ

การอ่านอย่างตรงไปตรงมาไม่ใช่ว่า reasoning เป็นเวทมนตร์ แต่คือเมื่อสิ่งเดียวที่ได้รับ reward คือการ ถูกต้อง และการถูกต้องในปัญหายากต้องอาศัยการทำงานผ่านมัน การทำงานผ่านมันก็คือสิ่งที่ optimiser หาเจอ — รวมถึงส่วนต่าง ๆ ของการทำงานผ่านมันที่มนุษย์ก็ทำด้วย เพราะมันเป็นสิ่งที่ปัญหาต้องการ ไม่ใช่สิ่งที่ใครสอน

Reasoning tokens คือบรรทัดหนึ่งในใบเรียกเก็บเงิน

ลิงก์ไปยังส่วน: Reasoning tokens คือบรรทัดหนึ่งในใบเรียกเก็บเงิน

ผลเชิงปฏิบัติของทั้งหมดนี้คือ reasoning model ผลิต token ที่คุณขอ และ token ที่คุณไม่ได้ขอ และคุณจ่ายทั้งสองอย่าง

provider จัดการเรื่องนี้ต่างกัน และความต่างนั้นสำคัญ:

API ส่วนใหญ่นับ reasoning tokens อยู่ภายใน จำนวน output token ใบเรียกเก็บเงินของคุณและ limit max_tokens ของคุณรวมการคิดที่คุณไม่เคยเห็นไว้ด้วย
Gemini ของ Google รายงาน thinking tokens เป็น field แยกต่างหาก อยู่นอกจำนวน output มาตรฐาน

นี่เป็นความไม่เข้ากันจริง ๆ ระหว่างสองวิธีในการนับสิ่งเดียวกัน และโค้ดใด ๆ ที่คำนวณต้นทุนหรือบังคับใช้ budget ข้าม provider ต้อง normalize มัน บทที่ 16 คือจุดที่สิ่งนี้กลายเป็นเงิน และ บทที่ 23 คือจุดที่มันกลายเป็น budget ที่คุณบังคับใช้ได้

ผลอีกอย่างคือเรื่อง latency ที่ทำให้คนประหลาดใจในครั้งแรก time to first visible token ของ reasoning model รวมการคิดทั้งหมดของมัน ดังนั้น request ที่ stream ว่างเปล่าแปดวินาทีแล้วตอบในหนึ่งวินาที ไม่ใช่ connection ค้าง — มันคือโมเดลกำลังทำงาน อินเทอร์เฟซใด ๆ ที่แสดง spinner โดยไม่อธิบายนานแปดวินาทีมีปัญหาด้าน design ไม่ใช่ networking

แกนที่สาม

scaling laws ใน บทที่ 10 มีปุ่มปรับสองอย่าง: parameters และ training data ทั้งสองถูกใช้จ่าย ก่อน โมเดลออกสู่การใช้งาน และทั้งสองถูกตรึงไว้ที่ inference time

Test-time compute คือแกนที่สาม และมันประพฤติตัวต่างจากอีกสองแกน: มันถูกใช้จ่ายต่อ request, ปรับเปลี่ยนได้ต่อ request และแลกกับ latency กับ cost โดยตรง แทนที่จะแลกกับ training budget Snell และคณะ⁷ แสดงว่าสำหรับบางปัญหา compute budget คงที่ให้ accuracy มากกว่าเมื่อใช้ที่ inference มากกว่าใช้กับโมเดลที่ใหญ่ขึ้น — ซึ่งกลับหัวสมมติฐานที่ว่าวิธีได้คำตอบที่ดีขึ้นคือโมเดลที่ใหญ่ขึ้น

การอ่านเชิงปฏิบัติ และเหตุผลที่นี่เป็นการตัดสินใจทางวิศวกรรมมากกว่างานวิจัย: โมเดลเล็กที่ได้รับพื้นที่ให้ทำงานสามารถชนะโมเดลใหญ่ที่ตอบทันทีได้ ด้วยต้นทุนที่คุณควบคุมต่อ request แทนที่จะควบคุมต่อ deployment การแลกนี้ดีหรือไม่ขึ้นอยู่กับว่า latency budget ของคุณมีมูลค่าแค่ไหน ซึ่งเป็นคำถามเกี่ยวกับผลิตภัณฑ์ของคุณ ไม่ใช่เกี่ยวกับโมเดล

เมื่อ “think step by step” เลิกช่วย

ลิงก์ไปยังส่วน: เมื่อ “think step by step” เลิกช่วย

คำเตือนปิดท้าย เพราะนี่คือวิธีที่เนื้อหาในบทนี้ถูกนำไปใช้ผิดบ่อยที่สุด

ทุกอย่างในครึ่งแรกคือเทคนิคสำหรับทำให้โมเดลที่ ไม่ได้ ถูกฝึกให้ reason ผลิต reasoning ออกมาอยู่ดี โมเดลที่ฝึกด้วย RLVR ทำสิ่งนี้อยู่แล้ว: มันปล่อยวิธีทำของตัวเอง ตามความยาวของตัวเอง ก่อนตอบ การบอกโมเดลแบบนั้นให้ think step by step อย่างดีที่สุดก็ซ้ำซ้อน และอย่างแย่ที่สุดก็เป็นโทษ — มันอาจผลิต chain สั้น ๆ ที่มีรูปทรงตาม prompt แทน chain ที่ยาวกว่าซึ่งโมเดลจะสร้างเอง และ provider บางรายก็ document เรื่องนี้ไว้ชัดเจน

สิ่งเดียวกันใช้กับโครง scaffold ของ reasoning ที่ซับซ้อนซึ่งสร้างใน application code prompt ที่พาโมเดลเดินผ่าน decision tree ที่มันนำทางภายในอยู่แล้ว คือการใช้ token ของคุณเพื่อจำกัดพฤติกรรมที่ถูกฝึกเข้าไปแล้ว นี่คือการปรากฏครั้งแรกของธีมที่จะวิ่งผ่านส่วนที่เหลือของคอร์ส: เทคนิคที่จำเป็นอย่างยิ่งในปี 2022 กลายเป็นความเชื่อโชคลางในปี 2025 และวิธีเดียวที่จะบอกได้ว่าอะไรเป็นอะไรสำหรับโมเดลของคุณในวันนี้ คือวัดทั้งสองแบบ

บทที่ 15 คือจุดที่การวัดนั้นกลายเป็นวินัย ไม่ใช่ความเห็น

ต่อจากนี้ไปที่ไหน

ลิงก์ไปยังส่วน: ต่อจากนี้ไปที่ไหน

Reasoning มีคุณสมบัติที่ชวนอึดอัดอย่างหนึ่ง: มันเป็นความสามารถเดียวที่ ต้นทุน scale ตามความยากของคำถาม โมเดลที่คิด 900 token ทำ forward pass 900 ครั้ง เก็บ cache ที่โตขึ้นใน memory สำหรับทั้งหมด และถือ GPU ไว้ตลอดช่วงนั้น

สิ่งนี้ทำให้เศรษฐศาสตร์ของการ serve reasoning model แย่กว่าการ serve chat model อย่างชัดเจน และเปลี่ยนรายละเอียดการ implement ชุดหนึ่งให้กลายเป็นความต่างระหว่างผลิตภัณฑ์ที่ viable กับที่ไม่ viable: cache ของ keys และ values ในอดีตถูกจัดเก็บและ reuse อย่างไร, request กี่รายการสามารถ share forward pass เดียวกันได้, และ weights ต้องใช้ precision มากแค่ไหนจริง ๆ

บทที่ 13 เป็นบทสุดท้ายที่โมเดลยังเป็น object ใน memory ของคุณ แทนที่จะเป็น service หลัง port และมันว่าด้วยการทำให้ object นั้นถูกพอที่จะ serve นอกจากนี้ยังขึ้นเงินตามสัญญาหนึ่งจากบทนี้: speculative decoding ซึ่งผลิต token หลายตัวด้วยราคาคร่าว ๆ เท่ากับหนึ่ง token โดยให้โมเดลเล็กเดาและโมเดลใหญ่ตรวจ — กลเม็ดที่สมเหตุสมผลก็ต่อเมื่อคุณเห็นแล้วว่า forward pass ใช้เวลาไปกับการรอ memory มากกว่าการทำเลขคณิตแค่ไหน

แหล่งที่มาและวิธีการ

ลิงก์ไปยังส่วน: แหล่งที่มาและวิธีการ

การวัดทั้งหมดในบทนี้มาจาก Qwen/Qwen2.5-0.5B-Instruct บนโจทย์ปัญหาคำสองขั้นตอนที่สร้างขึ้น 24 ข้อ ใช้ greedy decoding ยกเว้นจุดที่ระบุว่า sampling และไม่มี generation ใดถูกตัดที่ token caps ที่ใช้ ผลลัพธ์ทำซ้ำได้ และเป็นโมเดลเล็กบนโจทย์ง่าย: ให้อ่านผล self-consistency เป็นการสาธิตกลไก ไม่ใช่ benchmark บทที่ 18 ของบันทึก lecture CS229 และบทที่ 12 ของ Hugging Face LLM Course ต่างก็ครอบคลุมเนื้อหานี้ด้วยโมเดลที่ใหญ่กว่าและ benchmark ที่เหมาะสม

รายการอ้างอิง

ลิงก์ไปยังส่วน: รายการอ้างอิง

Wei, J. et al. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903 (2022). ↩
Kojima, T., Gu, S. S., Reid, M., Matsuo, Y. and Iwasawa, Y. Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916 (2022). ผลลัพธ์ “let's think step by step” ↩
Wang, X. et al. Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171 (2022). ↩
Yao, S. et al. Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601 (2023). ↩
Lightman, H. et al. Let's Verify Step by Step. arXiv:2305.20050 (2023). แนะนำ PRM800K ซึ่งเป็น dataset process supervision ขนาด 800,000 ขั้นตอน ↩
DeepSeek-AI. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948 (2025). ผลลัพธ์ R1-Zero — reinforcement learning ที่ใช้กับ base model โดยตรง โดยไม่มี supervised fine-tuning stage — อยู่ใน section 2.2 ↩
Snell, C., Lee, J., Xu, K. and Kumar, A. Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters. arXiv:2408.03314 (2024). ↩