ว่าทำไมโมเดลภาษาเสียทางในบทสนทนา

งานวิจัยใหม่จาก Microsoft Research และ Salesforce พบว่าแม้โมเดลภาษาขนาดใหญ่ (LLM) ที่มีความสามารถสูงสุดก็ยังล้มเหลวเมื่อมีการสั่งงานทีละขั้นตอนแทนการให้คำสั่งทั้งหมดในครั้งเดียว ผู้เขียนพบว่าประสิทธิภาพลดลงโดยเฉลี่ย 39% ในหกงานเมื่อคำสั่งถูกแบ่งออกเป็นหลายขั้นตอน

บทสนทนาที่มีผลลัพธ์ดีที่สุด (ซ้าย) และบทสนทนาที่โมเดลภาษาขนาดใหญ่ที่มีประสิทธิภาพสูงสุดเสียทางในบทสนทนา (ขวา)

สิ่งที่น่าประหลาดใจมากกว่านั้นคือ ความน่าเชื่อถือของคำตอบลดลงอย่างมาก โดยมีโมเดลที่มีชื่อเสียง เช่น ChatGPT-4.1 และ Gemini 2.5 Pro มีคำตอบที่ใกล้เคียงกับคำตอบที่สมบูรณ์แบบและคำตอบที่ล้มเหลวอย่างเห็นได้ชัด ขึ้นอยู่กับวิธีการสั่งงาน

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

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

สองรูปแบบสุดขั้วของบทสนทนาที่ร้านอาหาร (ไม่ได้มาจากงานวิจัยใหม่นี้ แต่เพื่อแสดงให้เห็นเท่านั้น)

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

การกำหนดค่านี้สะท้อนให้เห็นในแนวทาง “sharded” ใหม่ของ LLM ซึ่งแบ่งคำสั่งที่สมบูรณ์ออกเป็นชิ้นเล็กๆ ที่จะแนะนำในขณะสำคัญระหว่างการโต้ตอบกับ LLM

In fact, the researchers note what many of us have found anecdotally – that the best way to get the conversation back on track is to start a new conversation with the LLM.

‘If a conversation with an LLM did not lead to expected outcomes, starting a new conversation that repeats the same information might yield significantly better outcomes than continuing an ongoing conversation.

‘This is because current LLMs can get lost in the conversation, and our experiments show that persisting in a conversation with the model is ineffective. In addition, since LLMs generate text with randomness, a new conversation may lead to improved outcomes.’

The authors acknowledge that agentic systems such as Autogen or LangChain can potentially improve the outcomes by acting as interpretative layers between the end-user and the LLM, only communicating with the LLM when they have gathered enough ‘sharded’ responses to coagulate into a single cohesive query (which the end-user will not be exposed to).

However, the authors contend that a separate abstraction layer should not be necessary, or else be built directly into the source LLM:

‘An argument could be made that multi-turn capabilities are not a necessary feature of LLMs, as it can be offloaded to the agent framework. In other words, do we need native multi-turn support in LLMs when an agent framework can orchestrate interactions with users and leverage LLMs only as single-turn operators?…’

But having tested the proposition across their array of examples, they conclude:

‘[Relying] on an agent-like framework to process information might be limiting, and we argue LLMs should natively support multi-turn interaction’

This interesting new paper is titled LLMs Get Lost In Multi-Turn Conversation, and comes from four researchers across MS Research and Salesforce,

บทสนทนาที่แตกเป็นชิ้น

วิธีการใหม่นี้แบ่งคำสั่งที่สมบูรณ์ออกเป็นชิ้นเล็กๆ ที่จะแนะนำในขณะสำคัญระหว่างการโต้ตอบกับ LLM ซึ่งสะท้อนให้เห็นในแนวทาง “sharded” ใหม่ของ LLM

คำสั่งแต่ละคำสั่งเป็นคำสั่งที่สมบูรณ์แบบที่ส่งมอบงานทั้งหมดในครั้งเดียว โดยรวมคำถามระดับสูง คำสั่งสนับสนุน และเงื่อนไขที่เกี่ยวข้อง คำสั่ง “sharded” แบ่งออกเป็นหลายชิ้น โดยแต่ละชิ้นเพิ่มเพียงชิ้นเดียวของข้อมูล:

คำสั่งแบบคู่ที่แสดง (a) คำสั่งที่สมบูรณ์แบบที่ส่งมอบในครั้งเดียว และ (b) รูปแบบ “sharded” ที่ใช้ในการจำลองการโต้ตอบที่ไม่สมบูรณ์แบบและหลายขั้นตอน

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

การโต้ตอบที่จำลองเกิดขึ้นระหว่างสามส่วนประกอบ: ผู้ช่วย ซึ่งเป็นโมเดลที่กำลังถูกประเมิน; ผู้ใช้ ซึ่งเป็นตัวแทนจำลองที่มีการเข้าถึงคำสั่งเต็มรูปแบบในแบบ “sharded”; และ ระบบ ซึ่งดูแลและประเมินการแลกเปลี่ยน

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

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

แผนภาพของการจำลองการโต้ตอบที่ “sharded” โดยมีโมเดลที่ถูกประเมินเน้นด้วยสีแดง

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

ซิมูเลเตอร์ผู้ใช้ซึ่งใช้ GPT-4o-mini ได้รับการเข้าถึงคำสั่งเต็มรูปแบบและประวัติการโต้ตอบ โดยมีหน้าที่ตัดสินใจว่าจะเผยชิ้นใดต่อไปในแต่ละครั้งตามว่าการโต้ตอบกำลังดำเนินไปอย่างไร

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

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

GPT-4o-mini ยังถูกใช้เพื่อตัดสินใจว่าจะจัดประเภทคำตอบของโมเดลอย่างไร และเพื่อดึงคำตอบสุดท้ายออกมาจากคำตอบเหล่านั้น สิ่งนี้ช่วยให้การจำลองยังคงยืดหยุ่น แต่ก็ทำให้เกิดข้อผิดพลาดบ้าง: อย่างไรก็ตาม หลังจากตรวจสอบหลายร้อยการโต้ตอบด้วยมือ ผู้เขียนพบว่าน้อยกว่า 5% มีปัญหา และน้อยกว่า 2% แสดงถึงการเปลี่ยนแปลงของผลลัพธ์ เนื่องจากข้อผิดพลาดเหล่านี้ และพวกเขาถือว่าอัตราข้อผิดพลาดนี้ต่ำพอที่จะยอมรับได้ภายในขอบเขตของโครงการ

สถานการณ์จำลอง

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

ในสถานการณ์ เต็ม โมเดลได้รับคำสั่งเต็มรูปแบบในครั้งเดียว ซึ่งเป็นรูปแบบมาตรฐานและใช้เป็นฐานการเปรียบเทียบ

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

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

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

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

ประเภทของสถานการณ์จำลองตามคำสั่ง “sharded”

งานและมาตรการ

งานสร้างสรรค์หกงานถูกเลือกเพื่อปกปิดทั้งโดเมนการเขียนโปรแกรมและภาษาธรรมชาติ: การสร้างโค้ดถูกนำมาจาก HumanEval และ LiveCodeBench; ควอรี่ Text-to-SQL ถูกนำมาจาก Spider; การเรียก API ถูกสร้างขึ้นโดยใช้ข้อมูลจาก Berkeley Function Calling Leaderboard; ปัญหาคณิตศาสตร์ขั้นประถมศึกษาถูกนำมาจาก GSM8K; งานเขียนคำบรรยายตารางถูกสร้างขึ้นจาก ToTTo; และสรุปเอกสารหลายฉบับถูกนำมาจาก Summary of a Haystack dataset

ประสิทธิภาพของโมเดลถูกวัดโดยใช้มาตรการหลักสามประการ: ประสิทธิภาพโดยเฉลี่ย, ความสามารถ, และ ความไม่น่าเชื่อถือ

ประสิทธิภาพโดยเฉลี่ย บ่งบอกถึงประสิทธิภาพโดยรวมของโมเดลในหลายๆ การลอง; ความสามารถ สะท้อนถึงผลลัพธ์ที่ดีที่สุดที่โมเดลสามารถทำได้ตามผลลัพธ์ที่ได้คะแนนสูงสุด; และ ความไม่น่าเชื่อถือ วัดความแปรผันของผลลัพธ์ โดยช่องว่างที่ใหญ่กว่าระหว่างผลลัพธ์ที่ดีที่สุดและแย่ที่สุดบ่งชี้ถึงพฤติกรรมที่ไม่มั่นคง

คะแนนทั้งหมดถูกวางในมาตราส่วน 0-100 เพื่อให้แน่ใจถึงความสอดคล้องระหว่างงาน และมาตรการถูกคำนวณสำหรับคำสั่งแต่ละคำสั่ง – แล้วจึงเฉลี่ยเพื่อให้ภาพรวมของประสิทธิภาพของโมเดล

งานสร้างสรรค์หกงานที่ใช้ในการทดลอง โดยครอบคลุมทั้งการเขียนโปรแกรมและการสร้างภาษาธรรมชาติ

ผู้เข้าแข่งขันและการทดสอบ

ในสถานการณ์จำลองเริ่มต้น (โดยมีค่าใช้จ่ายประมาณ 5,000 ดอลลาร์) 600 คำสั่งครอบคลุมหกงานถูกแบ่งออกเป็นชิ้นเล็กๆ และใช้ในการจำลองการโต้ตอบสามประเภท: เต็ม, concat, และ sharded สำหรับแต่ละชุดของโมเดล คำสั่ง และประเภทการจำลอง การโต้ตอบสิบครั้งถูกดำเนินไป โดยสร้างการจำลองมากกว่า 200,000 ครั้ง – สิ่งนี้ทำให้สามารถจับประสิทธิภาพโดยรวมและวัดความสามารถและความน่าเชื่อถือได้ลึกซึ้งยิ่งขึ้น

โมเดล 15 โมเดลถูกทดสอบ โดยครอบคลุมผู้ให้บริการและสถาปัตยกรรมที่หลากหลาย: โมเดลของ OpenAI เช่น GPT-4o (รุ่น 2024-11-20), GPT-4o-mini (2024-07-18), GPT-4.1 (2025-04-14), และโมเดลการคิด o3 (2025-04-16)

โมเดลของ Anthropic คือ Claude 3 Haiku (2024-03-07) และ Claude 3.7 Sonnet (2025-02-19) โดยเข้าถึงผ่าน Amazon Bedrock

Google มีส่วนร่วมด้วย Gemini 2.5 Flash (preview-04-17) และ Gemini 2.5 Pro (preview-03-25) โมเดลของ Meta คือ Llama 3.1-8B-Instruct และ Llama 3.3-70B-Instruct รวมทั้ง Llama 4 Scout-17B-16E ผ่าน Together AI

รายการอื่นๆ คือ OLMo 2 13B, Phi-4, และ Command-A ซึ่งเข้าถึงได้โดยตรงผ่าน Ollama หรือ Cohere API; และ Deepseek-R1 ผ่าน Amazon Bedrock

สำหรับสองโมเดล “การคิด” (o3 และ R1) ‘การคิด’ โมเดลที่มีการเพิ่ม ขีดจำกัดโทเค็น เป็น 10,000 เพื่อรองรับการให้เหตุผลที่ยาวขึ้น:

คะแนนประสิทธิภาพโดยเฉลี่ยสำหรับแต่ละโมเดลทั่วหกงาน

เกี่ยวกับผลลัพธ์เหล่านี้ ผู้เขียนระบุ^†:

‘ในระดับสูง ทุกโมเดลเห็นประสิทธิภาพลดลงในทุกงาน เมื่อเปรียบเทียบประสิทธิภาพแบบ FULL และ SHARDED โดยมีการเสื่อมสภาพโดยเฉลี่ย -39% เราเรียกปรากฏการณ์นี้ว่า Lost in Conversation: โมเดลที่บรรลุประสิทธิภาพที่ยอดเยี่ยม (90%+) ในการกำหนดค่าแบบห้องปฏิบัติการของการโต้ตอบแบบเต็มรูปแบบและแบบเดียว ล้มเหลว ในงานเดียวกัน ในสถานการณ์ที่มีการโต้ตอบแบบหลายขั้นตอนและไม่สมบูรณ์แบบ’

คะแนนแบบ concat เฉลี่ย 95% ของ เต็ม ซึ่งบ่งชี้ว่าการเสื่อมสภาพในสถานการณ์แบบ sharded ไม่สามารถอธิบายได้ด้วยการสูญเสียข้อมูล โมเดลที่เล็กกว่า เช่น Llama3.1-8B-Instruct, OLMo-2-13B, และ Claude 3 Haiku แสดงถึงการเสื่อมสภาพที่ชัดเจนยิ่งขึ้นภายใต้ concat ซึ่งแนะนำว่าโมเดลที่เล็กกว่านั้นมีความทนทานต่อการเขียนใหม่น้อยกว่าโมเดลที่ใหญ่กว่า

ผู้เขียนสังเกตเห็น^†:

‘น่าประหลาดใจที่ โมเดลที่มีประสิทธิภาพสูงกว่า (Claude 3.7 Sonnet, Gemini 2.5, GPT-4.1) ตกอยู่ในสถานการณ์แบบเดียวกันกับโมเดลที่เล็กกว่า (Llama3.1-8B-Instruct, Phi-4) โดยมีการเสื่อมสภาพโดยเฉลี่ย 30-40% สิ่งนี้เป็นส่วนหนึ่งเนื่องมาจากคำจำกัดความของมาตรการ เนื่องจากโมเดลที่เล็กกว่าบรรลุคะแนนสัมบูรณ์ที่ต่ำกว่าใน FULL, mereka จึงมีศักยภาพในการเสื่อมสภาพน้อยกว่าเมื่อเปรียบเทียบกับโมเดลที่ดีกว่า

‘โดยสรุป ไม่ว่าโมเดล LLM จะมีประสิทธิภาพแบบเดียวอย่างไร เราพบว่ามีการเสื่อมสภาพที่มากในสถานการณ์แบบหลายขั้นตอน’

การทดสอบเบื้องต้นชี้ให้เห็นว่าบางโมเดลทนต่อสถานการณ์เฉพาะได้ดีกว่า: Command-A ในงาน Action, Claude 3.7 Sonnet และ GPT-4.1 ในงาน Code; และ Gemini 2.5 Pro ในงาน Data-to-Text ซึ่งบ่งชี้ว่าความสามารถในการโต้ตอบหลายขั้นตอนแตกต่างกันไปในแต่ละโดเมน โมเดลการคิด เช่น o3 และ Deepseek-R1 ไม่ได้ทำได้ดีกว่าโดยรวม ซึ่งอาจเป็นเพราะว่าคำตอบที่ยาวขึ้นของพวกมันแนะนำการสมมติซึ่งมีแนวโน้มที่จะทำให้การโต้ตอบสับสน

ความน่าเชื่อถือ

ความสัมพันธ์ระหว่างความสามารถและความน่าเชื่อถือที่ชัดเจนในสถานการณ์แบบเดียว ลดลงอย่างมากในสถานการณ์แบบหลายขั้นตอน ในขณะที่ความสามารถลดลงเพียงเล็กน้อย ความไม่น่าเชื่อถือ เพิ่มขึ้น โดยเฉลี่ย โมเดลที่มีความเสถียรในคำสั่งแบบเต็มรูปแบบ เช่น GPT-4.1 และ Gemini 2.5 Pro กลายเป็นไม่เสถียรเช่นเดียวกับโมเดลที่อ่อนแอกว่า เช่น Llama3.1-8B-Instruct หรือ OLMo-2-13B เมื่อคำสั่งถูกแบ่งออกเป็นชิ้นเล็กๆ

ภาพรวมของความสามารถและความไม่น่าเชื่อถือ

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

งานวิจัยระบุ^†:

‘[แม้ว่า] โมเดลที่ดีกว่าจะมีความสามารถในการโต้ตอบหลายขั้นตอนที่สูงกว่าเล็กน้อย แต่ทุกโมเดลที่เราทดสอบมีระดับความไม่น่าเชื่อถือที่คล้ายกัน ในอีกนัยหนึ่ง ในสถานการณ์แบบหลายขั้นตอนและไม่สมบูรณ์แบบ ทุกโมเดลที่เราทดสอบแสดงให้เห็นถึงความไม่น่าเชื่อถือที่สูงมาก โดยมีการเสื่อมสภาพ 50 คะแนนโดยเฉลี่ยระหว่างการวิ่งที่ดีที่สุดและแย่ที่สุดสำหรับคำสั่งที่กำหนด.’

เพื่อทดสอบว่าการเสื่อมสภาพของประสิทธิภาพมีความเกี่ยวข้องกับจำนวนการหมุนหรือไม่ ผู้เขียนดำเนินการทดลองการแบ่งชิ้นแบบค่อยเป็นค่อยไป โดยแบ่งคำสั่งแต่ละคำสั่งออกเป็น 1-8 ชิ้น

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

การควบคุมอุณหภูมิ

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

ในรูปแบบการโต้ตอบแบบเดียว เช่น เต็ม และ concat การลดอุณหภูมิของผู้ช่วยอย่างมีนัยสำคัญปรับปรุงความน่าเชื่อถือ โดยลดการเปลี่ยนแปลงถึง 80%; แต่ในสถานการณ์ sharded การแทรกแซงเดียวกันนั้นมีผลเพียงเล็กน้อย:

คะแนนความไม่น่าเชื่อถือสำหรับการผสมผสานต่างๆ ของอุณหภูมิผู้ช่วยและผู้ใช้ในสถานการณ์แบบเต็มรูปแบบ concat และ sharded

แม้ว่าอุณหภูมิของผู้ช่วยและผู้ใช้ทั้งคู่จะถูกตั้งค่าเป็นศูนย์ ความไม่น่าเชื่อถือก็ยังคงสูง โดยมีการเปลี่ยนแปลงประมาณ 30% สำหรับ GPT-4o ซึ่งแนะนำว่าความไม่มั่นคงที่สังเกตเห็นในการโต้ตอบหลายขั้นตอนไม่ได้เป็นเพียง เสียงสุ่ม แต่เป็นความอ่อนแอทางโครงสร้างในการจัดการข้อมูลที่แตกเป็นชิ้นเล็กๆ

ผลกระทบ

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

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

สุดท้าย พวกเขายืนยันว่าความสามารถในการโต้ตอบหลายขั้นตอนควรได้รับการปฏิบัติเป็นความสามารถหลักของโมเดล LLM ไม่ใช่สิ่งที่ถูกโหลดออกไปสู่ระบบภายนอก

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

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

พวกเขาสรุปว่า:

‘[เรา] เชื่อว่าการจำลองที่ดำเนินการทดสอบพื้นที่ที่ดีสำหรับความสามารถในการโต้ตอบหลายขั้นตอนของ LLM เนื่องจากเงื่อนไขที่ง่ายเกินไปของการจำลอง เราเชื่อว่าการเสื่อมสภาพที่สังเกตเห็นในการทดลองน่าจะเป็นการ ต่ำกว่า ความไม่น่าเชื่อถือของ LLM และความถี่ที่ LLM ตกอยู่ในสถานการณ์แบบหลายขั้นตอนในสถานการณ์จริง’

สรุป

ใครก็ตามที่ใช้เวลาอย่างมีนัยสำคัญกับโมเดลภาษาขนาดใหญ่ (LLM) น่าจะรู้จักปัญหาเหล่านี้จากประสบการณ์จริง และส่วนใหญ่ของเราน่าจะทิ้งการโต้ตอบที่ “สูญเสีย” ของ LLM ไว้เพื่อเริ่มใหม่ โดยหวังว่า LLM จะ “เริ่มต้นใหม่” และหยุดยั้งการคิดถึงสิ่งที่เกิดขึ้นในระหว่างการแลกเปลี่ยนที่ยาวและทำให้โกรธได้

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

* สับสน เนื่องจากสิ่งนี้ไม่เกี่ยวข้องกับ ความหมายทั่วไปของ ‘sharding’ ใน AI

† การเน้นด้วยตัวเขียนของตัวผู้เขียน

เผยแพร่ครั้งแรกวันจันทร์ 12 พฤษภาคม 2025