เจาะลึก GPT 6 Astra: การทำงานของ Looped Transformers

OpenAI อธิบายว่า GPT 6 Astra เป็นโมเดลที่มีความสามารถและสอดคล้องกับเป้าหมายมากที่สุดเท่าที่เคยมีมา

Greg Brockman กล่าวเพิ่มเติมว่า การมองว่า Astra เป็นรูปแบบเริ่มต้นของปัญญาประดิษฐ์ทั่วไป (AGI) นั้นเป็นเรื่องที่สมเหตุสมผล

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

ข้อกล่าวอ้างเหล่านั้นน่าทึ่ง แต่ไม่ใช่ส่วนที่สำคัญที่สุดของการเปิดตัวครั้งนี้

การเปลี่ยนแปลงที่แท้จริงอยู่ที่สถาปัตยกรรม

โมเดลภาษาทั่วไปจะส่งข้อมูลผ่านลำดับของบล็อก Transformer ที่ตายตัวและสร้าง Token ถัดไป แต่ Astra สามารถประมวลผลสถานะภายในของมันผ่านบล็อกการคำนวณเดียวกันหลายครั้งก่อนที่จะแสดงคำเดียวให้ผู้ใช้เห็น

มันไม่ได้แค่สร้างห่วงโซ่ความคิดที่ยาวขึ้น

มันใช้เวลาคิดมากขึ้นก่อนที่จะตอบ

1 โมเดลภาษาสมัยใหม่ทำงานอย่างไร

ลองนึกภาพการพิมพ์:

Everest คือ...

โมเดลต้องทำนายว่าสิ่งใดจะเกิดขึ้นต่อไป

กลไก Attention ของมันจะกำหนดว่าส่วนใดของบริบทที่มีความสำคัญ คำว่า Everest จะกระตุ้นแนวคิดที่เกี่ยวข้อง เช่น ภูเขา ความสูง เทือกเขาหิมาลัย เนปาล ทิเบต การปีนเขา และการสำรวจ

จากนั้นโมเดลจะรวมความสัมพันธ์เหล่านั้นกับบริบทรอบข้าง ในกรณีส่วนใหญ่ การต่อเนื่องเช่น "ภูเขาที่สูงที่สุดในโลก" จะมีความเป็นไปได้สูง

ภายใน Transformer ทั่วไป การแสดงผลนี้จะเคลื่อนที่ผ่านลำดับของบล็อก แต่ละบล็อกจะแปลงมันหนึ่งครั้งและส่งผลลัพธ์ไปยังบล็อกถัดไป

หากโมเดลมี 40 บล็อก สถานะที่ซ่อนอยู่จะเคลื่อนที่ผ่านทั้ง 40 บล็อกตามลำดับ การแสดงผลสุดท้ายจะถูกแปลงเป็นการกระจายความน่าจะเป็นสำหรับ Token ถัดไป

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

แต่การเพิ่มบล็อกก็เพิ่มจำนวนพารามิเตอร์ ความต้องการหน่วยความจำ และต้นทุนการฝึกอบรมด้วยเช่นกัน

สมมติฐานปกติเคยเรียบง่าย: หากคุณต้องการโมเดลที่ลึกขึ้น คุณต้องสร้างชั้นของเลเยอร์ที่ใหญ่ขึ้น

สถาปัตยกรรมแบบวนซ้ำ (Looped Architecture) เปลี่ยนหลักการนั้น

2 สิ่งที่สถาปัตยกรรมแบบวนซ้ำเปลี่ยนแปลง

ตามรายงานจาก The Information GPT 6 Astra ใช้สถาปัตยกรรม Transformer แบบวนซ้ำ

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

แทนที่จะส่งสถานะที่ซ่อนอยู่ผ่านทุกบล็อกเพียงครั้งเดียว โมเดลสามารถส่งผลลัพธ์กลับไปยังบล็อกการคำนวณและประมวลผลอีกครั้ง

ให้คิดว่ามันเป็นร่างภายใน

โมเดลสร้างการแสดงผลเบื้องต้น ส่งผ่านน้ำหนักชุดเดียวกันอีกครั้ง ปรับปรุง และทำซ้ำกระบวนการหลายครั้ง หลังจากที่ลูปเสร็จสมบูรณ์เท่านั้น Token ที่มองเห็นได้ถัดไปจึงจะปรากฏ

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

รายละเอียดสำคัญคือจำนวนพารามิเตอร์ไม่จำเป็นต้องเพิ่มขึ้น

น้ำหนักชุดเดียวกันถูกนำมาใช้ซ้ำในทุกครั้งที่ผ่าน

สิ่งที่เพิ่มขึ้นคือปริมาณการคำนวณ

ใน Transformer ทั่วไป Token จะเดินทางผ่านลำดับของบล็อกที่แตกต่างกัน ใน Transformer แบบวนซ้ำ มันสามารถเดินทางผ่านโครงสร้างที่ใช้ร่วมกันเดียวกันหลายครั้ง

โมเดลจะลึกขึ้นผ่านการคำนวณโดยไม่ต้องใหญ่ขึ้นผ่านจำนวนพารามิเตอร์

สิ่งนี้สร้างการแลกเปลี่ยนใหม่:

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

ประเด็นสุดท้ายสำคัญเป็นพิเศษ ความลึกในการคำนวณสามารถเปลี่ยนแปลงได้โดยไม่ต้องสร้างโมเดลใหม่

3 การฝึกความลึกแบบวนซ้ำ (Recurrent Depth)

การวางบล็อก Transformer ภายในลูปเพียงอย่างเดียวนั้นไม่เพียงพอ

หากโมเดลทำงาน 32 รอบพอดีระหว่างการฝึก มันอาจเรียนรู้ที่จะพึ่งพาตำแหน่งของแต่ละขั้นตอน รอบแรกอาจเรียนรู้ฟังก์ชันหนึ่ง รอบที่สิบอีกฟังก์ชันหนึ่ง และรอบที่สามสิบสองอาจกลายเป็นเลเยอร์เอาต์พุตที่ตายตัว

ผลลัพธ์ก็คือเครือข่าย 32 เลเยอร์ทั่วไปที่ปลอมตัวเป็นลูป

นักวิจัยแก้ปัญหานี้โดยการเปลี่ยนจำนวนรอบแบบวนซ้ำระหว่างการฝึก

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

ในแต่ละขั้นตอนการฝึก จำนวนลูปถูกสุ่มจากการแจกแจงที่มีค่าเฉลี่ยใกล้ 32 ตัวอย่างหนึ่งอาจได้รับสี่รอบ อีกตัวอย่าง 17 รอบ อีกตัวอย่าง 40 รอบ และอีกตัวอย่างใกล้ 90 รอบ

โมเดลไม่สามารถรู้ล่วงหน้าได้ว่ารอบไหนจะเป็นรอบสุดท้าย

ดังนั้นมันจึงต้องเรียนรู้บางสิ่งที่ทั่วไปกว่าลำดับการทำงานที่ตายตัว

มันต้องเรียนรู้วิธีปรับปรุงสถานะภายในปัจจุบันของมัน

บทคัดย่อจากเอกสาร Recurrent Depth บน arXiv

การฝึกผ่านขั้นตอนแบบวนซ้ำหลายสิบขั้นตอนสร้างปัญหาอีกประการ: หน่วยความจำ

Backpropagation มาตรฐานจะต้องจัดเก็บ Activation ระดับกลางจากทุก ๆ ลูป ด้วยการทำซ้ำที่มากพอ ต้นทุนหน่วยความจำก็จะมหาศาล

นักวิจัยของ Huginn ใช้การประนีประนอมในทางปฏิบัติ การส่งผ่านไปข้างหน้าสามารถทำงานได้หลายลูป แต่ Gradient จะถูกคำนวณผ่านแปดรอบสุดท้ายเท่านั้น

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

สิ่งนี้คล้ายกับ Truncated Backpropagation Through Time ความแตกต่างคือการเกิดซ้ำเกิดขึ้นในเชิงความลึกของการคำนวณมากกว่าข้ามคำในลำดับ

จำนวนลูปถูกสุ่มในทุกขั้นตอนการฝึก ในขณะที่ Gradient ถูกคำนวณผ่านแปดรอบสุดท้ายเท่านั้น

โมเดลไม่ได้ถูกสอนให้ดำเนินการตามลำดับ 32 ขั้นตอนที่ตายตัว

มันถูกสอนให้ย้ายสถานะที่ซ่อนอยู่ไปสู่คำตอบที่เป็นประโยชน์ไม่ว่ากระบวนการจะถูกหยุดเมื่อใด

นั่นเปลี่ยนความหมายของความลึก

ความลึกไม่ใช่แค่คุณสมบัติที่วิศวกรเลือกก่อนการฝึกอีกต่อไป มันสามารถกลายเป็นตัวแปรระหว่างการอนุมานได้

4 การคำนวณแบบปรับตัวระหว่างการอนุมาน

การควบคุมการใช้เหตุผลในปัจจุบันส่วนใหญ่ทำงานในระดับของ Token ที่มองเห็นได้

หากโมเดลถูกขอให้คิดนานขึ้น มันจะสร้างห่วงโซ่ความคิดที่ยาวขึ้น ใช้ Token เอาต์พุตมากขึ้น หรือสร้างข้อความกลางเพิ่มเติม

สถาปัตยกรรมแบบวนซ้ำนำเสนอกลไกที่แตกต่าง

จำนวนรอบภายในสามารถเปลี่ยนแปลงได้โดยไม่ต้องปรับเปลี่ยนน้ำหนักและไม่ต้องบังคับให้โมเดลเขียนคำอธิบายที่ยาวขึ้น

งานง่าย ๆ อาจได้รับสี่รอบ

การพิสูจน์ทางคณิตศาสตร์ที่ยากอาจได้รับ 32 รอบ

ปัญหาการเขียนโค้ดที่ซับซ้อนอาจได้รับ 64 รอบ

โมเดลยังคงเหมือนเดิม มีเพียงปริมาณการคำนวณภายในเท่านั้นที่เปลี่ยนแปลง

น้ำหนักยังคงคงที่ มีเพียงจำนวนรอบภายในที่ใช้ในการประมวลผลแต่ละ Token เท่านั้นที่เปลี่ยนแปลง

การทดลองความลึกแบบวนซ้ำสาธารณะแสดงรูปแบบที่คาดหวังไว้แล้ว

ประสิทธิภาพดีขึ้นอย่างรวดเร็วในช่วงลูปแรก จากนั้นการปรับปรุงจะน้อยลงจนกระทั่งเส้นโค้งเข้าใกล้ที่ราบสูง

สิ่งนี้ชี้ให้เห็นว่าสถานะที่ซ่อนอยู่กำลังลู่เข้า

รอบแรกทำการแก้ไขครั้งใหญ่ รอบหลังปรับแต่งรายละเอียดเล็กน้อย ในที่สุด การคำนวณเพิ่มเติมก็หยุดสร้างการปรับปรุงที่มีความหมาย

ระบบในอนาคตสามารถตรวจจับช่วงเวลานั้นได้โดยอัตโนมัติ

แทนที่จะกำหนดจำนวนลูปคงที่ให้กับทุก Prompt โมเดลสามารถประมวลผลต่อไปจนกว่าสถานะที่ซ่อนอยู่จะคงที่เพียงพอ Token ง่าย ๆ จะมีต้นทุนต่ำ Token ที่ยากจะได้รับการคำนวณมากขึ้น

นั่นจะสร้างความลึกในการคำนวณแบบปรับตัวอย่างแท้จริง

การคิดนานขึ้นจะไม่จำเป็นต้องหมายถึงการเขียนมากขึ้นอีกต่อไป

5 งานวิจัยและผลลัพธ์เชิงปฏิบัติในระยะแรก

การใช้เลเยอร์ Transformer ซ้ำไม่ใช่แนวคิดใหม่

Universal Transformers นำเสนอการประมวลผลแบบวนซ้ำในปี 2018 ALBERT ลดจำนวนพารามิเตอร์โดยการแชร์น้ำหนักข้ามเลเยอร์ Mixture of Recursions สำรวจการกำหนดเส้นทาง Token ผ่านปริมาณการคำนวณที่แตกต่างกัน

โมเดลโอเพนซอร์ส Nanbeige4.2 3B เป็นตัวอย่างที่ตรงไปตรงมาเป็นพิเศษ

การกำหนดค่าประกอบด้วย 22 เลเยอร์และ num_loops: 2 ในทางปฏิบัติ โมเดลจะเดินทางผ่านเลเยอร์เหล่านั้นสองครั้ง มันมีจำนวนพารามิเตอร์โดยประมาณของเครือข่าย 22 เลเยอร์ แต่มีความลึกในการคำนวณประมาณของเครือข่าย 44 เลเยอร์

การกำหนดค่า Nanbeige4.2 3B บน Hugging Face

ยี่สิบสองเลเยอร์, num_loops: 2, และใบอนุญาต Apache 2.0 กลไกนี้ปรากฏให้เห็นแล้วในการกำหนดค่าโมเดลโอเพนซอร์ส

เป็นเวลาหลายปีที่การออกแบบ Transformer แบบวนซ้ำยังคงเป็นแนวคิดการวิจัยที่น่าสนใจมากกว่าแนวทางหลัก

ส่วนประกอบที่ขาดหายไปคือหลักฐานการขยายขนาดที่แข็งแกร่ง

ในวันที่ 1 กันยายน นักวิจัยกลุ่มหนึ่งได้ตีพิมพ์ SMELT ซึ่งเป็นการศึกษาที่ออกแบบมาเพื่อเปรียบเทียบ Transformer แบบวนซ้ำและแบบทั่วไปภายใต้เงื่อนไขที่เท่าเทียมกัน

พวกเขาควบคุมจำนวนพารามิเตอร์ การคำนวณการฝึก และขนาด KV Cache ภายใต้ข้อจำกัดเหล่านั้น โมเดลแบบวนซ้ำต้องการการคำนวณการฝึกน้อยกว่า 6.8% ถึง 18% เพื่อให้ถึงระดับประสิทธิภาพเดียวกัน

การปรับปรุงที่มากที่สุดปรากฏในงานเขียนโค้ด

บทคัดย่อจากเอกสาร SMELT บน arXiv

เมื่อการคำนวณ พารามิเตอร์ และ KV Cache เท่ากัน การวนซ้ำช่วยประหยัดการคำนวณการฝึกได้ 6.8% ถึง 18% โดยการปรับปรุงที่แข็งแกร่งที่สุดในงานเขียนโค้ด

นักวิจัยยังสังเกตเห็นการเปลี่ยนแปลงในพฤติกรรม Attention

ใน Transformer ทั่วไป Token แรกสุดในลำดับมักจะกลายเป็น Attention Sink พวกมันได้รับ Attention ในสัดส่วนที่ไม่สมส่วนแม้ว่าความสำคัญทางความหมายจะจำกัด

หลังจากผ่านบล็อกเดียวกันเป็นครั้งที่สอง Attention ของโมเดลก็เปลี่ยนไปยัง Token ที่เกี่ยวข้องมากขึ้น

ลูปที่สองไม่ได้เพียงแค่ทำซ้ำลูปแรก มันใช้ผลลัพธ์ของลูปแรกเป็นรากฐานสำหรับการประมวลผลที่เลือกสรรมากขึ้น

SMELT ไม่ได้พิสูจน์ว่าทุกโมเดลในอนาคตควรเป็นแบบวนซ้ำ แต่มันแสดงให้เห็นว่าการวนซ้ำยังคงแข่งขันได้หลังจากจับคู่เงื่อนไขการทดลองหลักแล้ว

คำถามไม่ใช่อีกต่อไปว่าความลึกแบบวนซ้ำสามารถทำงานได้หรือไม่

คำถามคือมันสามารถขยายขนาดได้ไกลแค่ไหน

6 การตีความและการควบคุม

คุณลักษณะทางสถาปัตยกรรมเดียวกันที่ทำให้ลูปน่าสนใจก็ทำให้การตรวจสอบโมเดลซับซ้อนขึ้นเช่นกัน

ด้วยการใช้เหตุผลแบบ Chain of Thought ที่ชัดเจน อย่างน้อยขั้นตอนกลางบางส่วนจะปรากฏเป็นข้อความที่อ่านได้ นักวิจัยสามารถตรวจสอบ ค้นหารูปแบบที่น่าสงสัย และเปรียบเทียบการใช้เหตุผลที่ระบุกับคำตอบสุดท้าย

โมเดลแบบวนซ้ำสามารถประมวลผลภายใน Activation ที่ซ่อนอยู่ได้มากขึ้นโดยไม่ต้องสร้างข้อความใด ๆ

Buck Shlegeris และ Ryan Greenblatt ได้โต้แย้งว่าสิ่งนี้อาจลดประโยชน์ของการตรวจสอบ Chain of Thought หากการประมวลผลเคลื่อนเข้าสู่การคำนวณที่ซ่อนอยู่มากขึ้น คำอธิบายที่มองเห็นได้อาจเปิดเผยน้อยลงว่าโมเดลไปถึงผลลัพธ์ได้อย่างไร

Sebastian Raschka นำเสนอข้อโต้แย้งที่สำคัญ

การใช้น้ำหนักซ้ำไม่ได้สร้างความรู้ความเข้าใจที่เป็นความลับหรือไม่สามารถเข้าถึงได้โดยอัตโนมัติ Activation ภายในยังคงสามารถศึกษาได้ด้วยเครื่องมือตีความ ความแตกต่างหลักคือโมเดลอาจต้องการ Token กลางที่มองเห็นได้น้อยลงเนื่องจากการคำนวณมากขึ้นเกิดขึ้นก่อนการสร้างเริ่มต้น

Jakub Pachocki หัวหน้านักวิทยาศาสตร์ของ OpenAI ยังกล่าวอีกว่ากราฟการคำนวณของ Astra ยังคงอยู่ในช่วงประมาณสองเท่าของความลึกของ GPT 4 และลูปถูกจำกัดโดยเจตนาเพื่อรักษาความสามารถในการตรวจสอบ

นั่นชี้ให้เห็นถึงการใช้งานที่ถูกจำกัดมากกว่ากระบวนการวนซ้ำที่ไม่จำกัด

Chain of Thought ไม่ได้รับประกันว่าจะเป็นบันทึกที่เที่ยงตรงของการคำนวณภายในของโมเดลตั้งแต่แรก ระบบได้รับรางวัลสำหรับการสร้างคำตอบที่เป็นประโยชน์ ไม่ใช่สำหรับการให้รายงานที่ถูกต้องตามหลักวิทยาศาสตร์ของการทำงานที่ซ่อนอยู่ทุกครั้ง

งานวิจัยที่เกี่ยวข้องกับ OpenAI, Anthropic และ Google DeepMind แสดงให้เห็นว่าคำอธิบายของโมเดลสามารถละเว้นปัจจัยสำคัญ ให้เหตุผลกับการตัดสินใจหลังจากข้อเท็จจริง หรือนำเสนอเส้นทางที่สะอาดกว่าที่มีอิทธิพลต่อผลลัพธ์จริง

สถาปัตยกรรมแบบวนซ้ำทำให้ความแตกต่างนี้ยากที่จะเพิกเฉย

การใช้เหตุผลที่มองเห็นได้อาจเป็นเพียงอินเทอร์เฟซ

การคำนวณหลักอาจเกิดขึ้นภายในโมเดลก่อนที่ข้อความใดจะปรากฏ

7 ผลลัพธ์ของ GPT 6 Astra

ผลลัพธ์ Benchmark ที่น่าทึ่งที่สุดของ GPT 6 Astra คือคะแนน 99.9% บน ARC AGI 3

ตัวเลขนั้นฟังดูเกือบจะสิ้นสุด แต่มันขึ้นอยู่กับวิธีการทดสอบเป็นอย่างมาก

Simon Willison ชี้ให้เห็นว่าผลลัพธ์ 99.9% มาจากชุดทดสอบ Provider Adapter ที่กำหนดเองของ OpenAI ภายใต้ชุดทดสอบ ARC Prize มาตรฐาน โมเดลเดียวกันได้คะแนน 62.7%

โมเดลไม่ได้เปลี่ยนแปลง

สภาพแวดล้อมการประเมินต่างหากที่เปลี่ยน

โมเดลเดียวกันสร้างคะแนนที่แตกต่างกันสองคะแนนด้วยต้นทุนการรันที่แตกต่างกันสองแบบ

การรันของ OpenAI มีต้นทุนประมาณ 19,000 ดอลลาร์ การรันมาตรฐานมีต้นทุนประมาณ 26,000 ดอลลาร์

คะแนนที่สูงกว่าอย่างมีนัยสำคัญยังถูกสร้างขึ้นโดยการตั้งค่าที่ถูกกว่า

นั่นไม่ได้ทำให้ผลลัพธ์ไม่ถูกต้องโดยอัตโนมัติ Adapter ที่กำหนดเองอาจโต้ตอบกับโมเดลได้อย่างมีประสิทธิภาพมากขึ้นหรือเปิดเผยความสามารถที่กรอบการประเมินทั่วไปมองไม่เห็น

แต่ตัวเลขพาดหัวไม่สามารถตีความแยกจากเงื่อนไขที่สร้างมันขึ้นมาได้

GPT 6 Astra บน ARC AGI 3

หนึ่งโมเดล, ชุดทดสอบสองแบบ, และช่องว่าง 37.2 จุดเปอร์เซ็นต์

การประเมินอื่น ๆ ไม่น่าทึ่งเท่า

ในดัชนี Artificial Analysis Intelligence Astra ได้คะแนนประมาณเท่ากับ GPT 5.6 Sol และต่ำกว่า Claude Fable 5.1 ประมาณห้าจุด

ข้อได้เปรียบเชิงปฏิบัติมากกว่าอาจเป็นประสิทธิภาพในงาน Agentic ซึ่งมันสามารถเข้าถึงประสิทธิภาพที่แข่งขันได้ในต้นทุนที่ต่ำกว่า

Benchmark แสดงให้เห็นว่าโมเดลสามารถทำอะไรได้บ้าง สถาปัตยกรรมช่วยอธิบายว่าความสามารถเหล่านั้นมาจากไหนและอาจพัฒนาไปอย่างไร

8 ความหมายสำหรับอนาคตของ AI

เป็นเวลาหลายปีที่การขยายขนาดโมเดลภาษาส่วนใหญ่หมายถึงการเพิ่มพารามิเตอร์ เพิ่มข้อมูล และสร้างกองบล็อก Transformer ที่ตายตัวที่ใหญ่ขึ้น

ทุกเจเนอเรชันใหม่มีขนาดใหญ่ขึ้น แพงขึ้น และต้องการทรัพยากรมากขึ้นในการรัน

GPT 6 Astra ชี้ไปยังเส้นทางอื่น

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

สิ่งนี้แยกขนาดโมเดลออกจากความลึกของการใช้เหตุผล

แทนที่จะปฏิบัติตามเส้นทางการคำนวณที่ตายตัวเส้นทางเดียว ระบบสามารถปรับปริมาณงานให้เข้ากับความยากของปัญหาเฉพาะ

นั่นสามารถเปลี่ยนทั้งประสิทธิภาพของโมเดลและเศรษฐศาสตร์ของการใช้ AI ความฉลาดเดียวกันสามารถทำงานในโหมดที่รวดเร็วและราคาถูกสำหรับคำขอที่เรียบง่าย จากนั้นเพิ่มความลึกในการคำนวณเมื่องานต้องการการใช้เหตุผลมากขึ้นอย่างแท้จริง

การเกิดซ้ำกำลังกลับมาสู่โมเดลภาษา ครั้งนี้ มันทำงานไม่ใช่ระหว่างคำเป็นหลัก แต่อยู่ภายในกระบวนการที่สร้างคำเหล่านั้น

ระบบรุ่นต่อไปอาจไม่ทรงพลังมากขึ้นเพียงเพราะมันมีพารามิเตอร์มากขึ้น

ข้อได้เปรียบที่กำหนดของพวกมันอาจเป็นการรู้ว่าเมื่อใดที่พบคำตอบที่ดีแล้ว และเมื่อใดที่คุ้มค่าที่จะวนรอบภายในอีกครั้ง