เข้าใจขีดจำกัดหน้าต่างบริบท
สาเหตุหนึ่งของการล้มเหลวของ API ที่พบบ่อยที่สุดคือการเกินหน้าต่างบริบท หน้าต่างบริบทกำหนดจำนวนโทเคนสูงสุดที่โมเดลสามารถประมวลผลในคำขอเดียว รวมถึงอินพุต (พรอมต์ ประวัติ เครื่องมือ) และเอาต์พุต (การสร้าง) หากจำนวนโทเนนรวมของคุณเกินขีดจำกัดนี้ API จะส่งข้อผิดพลาดหรือตัดการตอบสนองของคุณแบบคาดเดาไม่ได้
ตัวอย่างเช่น หากคุณใช้โมเดล Qwen แบบไม่เซ็นเซอร์ที่มีหน้าต่างบริบท 100,000 โทเคน คุณต้องมั่นใจว่าประวัติการสนทนาของคุณรวมกับพรอมต์ใหม่ไม่เกินเกณฑ์นี้ นักพัฒนาหลายคนล้มเหลวในการติดตามจำนวนโทเคนสะสมของเซสชันที่ยาวนาน นำไปสู่การหยุดผสานรวมอย่างกะทันหันเมื่อถึงขีดจำกัด
- ติดตามการใช้งานโทเคน: ใช้ไลบรารีตัวแยกโทเคนที่สอดคล้องกับตัวแยกโทเคนของโมเดลเพื่อนับโทเคนอย่างถูกต้อง
- ตัดประวัติ: ใช้ตรรกะเพื่อลบข้อความเก่าเมื่อหน้าต่างบริบทเต็ม
- ติดตามขีดจำกัด: ตรวจสอบส่วนหัวการตอบสนอง API สำหรับความจุบริบทที่เหลือหากมีให้
การเพิกเฉยต่อขีดจำกัดเหล่านี้ไม่ได้ทำให้เกิดข้อผิดพลาดเท่านั้น แต่ยังอาจทำให้คุณภาพการตอบสนองลดลงเนื่องจากโมเดลพยายามสนใจข้อมูลที่เกี่ยวข้องในหน้าต่างที่แออัด
จัดการการตอบกลับสตรีมมิงให้ถูกต้อง
สตรีมมิงเป็นฟีเจอร์มาตรฐานสำหรับ API LLM รุ่นใหม่ ช่วยให้คุณได้รับส่วนการตอบสนองขณะที่กำลังสร้าง อย่างไรก็ตาม นักพัฒนาหลายคนเข้าใจผิดว่าสตรีมมิงส่งวัตถุ JSON สมบูรณ์สำหรับแต่ละชิ้น ในความเป็นจริง สตรีมมิงส่งชุดเหตุการณ์ที่ส่งผ่านเซิร์ฟเวอร์ (SSE) แต่ละชุดมีเศษ JSON บางส่วน
หากคุณใช้ไคลเอนต์ HTTP มาตรฐานโดยไม่มีการสนับสนุน SSE คุณอาจต้องแยกวิเคราะห์สตรีมข้อความดิบ โดยแบ่งตามบรรทัด data: และแยกวิเคราะห์วัตถุ JSON แต่ละชิ้น การล้มเหลวในการจัดการสิ่งนี้อย่างถูกต้องอาจนำไปสู่ข้อผิดพลาด JSON ที่แตกหรือข้อความที่ตัดทอน
นอกจากนี้ ให้แน่ใจว่า UI หรือไลบรารีไคลเอนต์ของคุณได้รับการออกแบบเพื่อเพิ่มข้อความแบบเพิ่มทีละส่วนแทนที่จะแทนที่เนื้อหาก่อนหน้า สตรีมมิงยังส่งผลต่อการนับโทเคน คุณต้องนับโทเคนเมื่อได้รับเพื่ออยู่ภายในขีดจำกัดอัตราและข้อจำกัดงบประมาณ
ข้อผิดพลาดการจัดรูปแบบพรอมต์ทั่วไป
LLMs มีความไวต่อการจัดรูปแบบพรอมต์ ความเบี่ยงเบนเล็กน้อยจากโครงสร้างที่คาดหวังอาจนำไปสู่ประสิทธิภาพต่ำหรือข้อผิดพลาดในการแยกวิเคราะห์ โดยเฉพาะเมื่อใช้การเรียกใช้ฟังก์ชัน ตัวอย่างเช่น หากคุณใช้การเรียกใช้ฟังก์ชัน โมเดลคาดหวังแผนผัง JSON เฉพาะในพรอมต์ หากพรอมต์ของคุณมีช่องว่างเพิ่มเติม คอมม่าที่ขาดหายไป หรือชื่อคีย์ที่ไม่ถูกต้อง โมเดลอาจล้มเหลวในการสร้างการเรียกใช้เครื่องมือที่ถูกต้อง
- ใช้เทมเพลต: ใช้ไลบรารีเทมเพลตพรอมต์ที่สอดคล้องกันเพื่อลดข้อผิดพลาดในการจัดรูปแบบด้วยตนเอง
- ตรวจสอบ JSON: ตรวจสอบ JSON เอาต์พุตกับแผนผังที่คาดหวังของคุณเสมอก่อนประมวลผล
- ทดสอบกรณีขอบ: ทดสอบพรอมต์ด้วยอักขระพิเศษ บรรทัดใหม่ และความยาวที่แตกต่างกันเพื่อให้มั่นใจถึงความแข็งแกร่ง
เมื่อผสานรวมกับโมเดล Qwen แบบไม่เซ็นเซอร์ ให้แน่ใจว่ารูปแบบพรอมต์ของคุณตรงกับโครงสร้างข้อมูลการฝึกของโมเดล รูปแบบที่ไม่ตรงกันอาจนำไปสู่การที่โมเดลเพิกเฉยต่อคำแนะนำหรือสร้างเอาต์พุตที่ผิดปกติ
ขีดจำกัดอัตราและการจราจรแบบพุ่งสูง
API ใช้ขีดจำกัดอัตราเพื่อป้องกันการละเมิดและรับประกันประสิทธิภาพที่เสถียร ข้อผิดพลาดทั่วไปคือการส่งคำขอแบบบัสต์ที่เกินขีดจำกัดต่อนาที ทำให้คำขอถัดไปล้มเหลวด้วยข้อผิดพลาด 429 Too Many Requests นักพัฒนาหลายคนมองข้ามสิ่งนี้โดยการทดสอบด้วยปริมาณการจราจรต่ำแล้วปรับใช้ในระดับใหญ่โดยไม่ปรับกลยุทธ์คำขอของพวกเขา
ตัวอย่างเช่น หาก API อนุญาต 300 คำขอต่อนาที การส่ง 301 คำขอในหนึ่งนาทีจะทำให้คำขอสุดท้ายล้มเหลว เพื่อหลีกเลี่ยงสิ่งนี้ ให้ใช้การหน่วงแบบเอกซ์โพเนนเชียลในไลบรารีไคลเอนต์ของคุณ กลยุทธ์นี้จะรอให้นานขึ้นระหว่างการลองใหม่หลังจากแต่ละครั้งล้มเหลว ป้องกันการแออัดเพิ่มเติม
นอกจากนี้ ให้ติดตามรูปแบบคำขอของคุณ หากคุณกำลังประมวลผลชุดข้อมูลขนาดใหญ่ ให้พิจารณาเว้นระยะคำขอตามเวลาแทนที่จะส่งทั้งหมดในครั้งเดียว สิ่งนี้รับประกันประสิทธิภาพที่สม่ำเสมอและหลีกเลี่ยงการชนขีดจำกัดที่แข็ง
การคำนวณจำนวนโทเคนผิดพลาด
การนับโทเคนมักถูกประเมินต่ำเกินไป นักพัฒนาจำนวนมากนับอักขระหรือคำแทนที่จะเป็นโทเคน นำไปสู่ต้นทุนที่ไม่คาดคิดหรือการล้นหน้าต่างบริบท ตัวแยกโทเคนแบ่งข้อความออกเป็นคำย่อย ซึ่งหมายความว่าคำเดียวอาจนับเป็นหลายโทเคน โดยเฉพาะสำหรับภาษาที่ไม่ใช่ภาษาอังกฤษหรือศัพท์เทคนิค
ตัวอย่างเช่น คำว่า uncensored อาจนับเป็นหลายโทเคนขึ้นอยู่กับตัวแยกโทเคน ใช้ตัวแยกโทเคนทางการที่ให้บริการโดยผู้ให้บริการ API เสมอเพื่อรับจำนวนที่ถูกต้อง สิ่งนี้สำคัญมากสำหรับการคำนวณต้นทุนเนื่องจากราคาปกติคือต่อ 1M โทเคน
- ใช้ตัวแยกโทเคนทางการ: หลีกเลี่ยงการประมาณเช่น 4 อักขระต่อโทเคน
- นับอินพุตและเอาต์พุต: จำไว้ว่าโทเคนพรอมต์และการสร้างทั้งสองถูกเรียกเก็บเงิน
- ติดตามการใช้งาน: ตั้งการแจ้งเตือนสำหรับการใช้งานโทเคนสูงเพื่อหลีกเลี่ยงค่าใช้จ่ายที่ไม่คาดคิด
การนับโทเคนที่แม่นยำช่วยให้คุณอยู่ภายในงบประมาณและขีดจำกัดบริบท ป้องกันการหยุดให้บริการระหว่างการดำเนินการที่สำคัญ
ปัญหาการกำหนดค่าการเรียกใช้ฟังก์ชัน
การเรียกใช้ฟังก์ชันอนุญาตให้โมเดลเรียกใช้ฟังก์ชันภายนอก แต่ต้องการการกำหนดค่าที่แม่นยำ ข้อผิดพลาดทั่วไปคือการไม่ตรงกันระหว่างแผนผังฟังก์ชันที่กำหนดในการร้องขอ API กับการใช้งานฟังก์ชันจริงในโค้ดของคุณ หากแผนผังระบุประเภทพารามิเตอร์ที่ไม่ตรงกับลายเซ็นของฟังก์ชันของคุณ โมเดลอาจสร้างอาร์กิวเมนต์ที่ไม่ถูกต้อง
อีกปัญหาคือลืมรวมผลลัพธ์การเรียกใช้ฟังก์ชันในพรอมต์ถัดไป โมเดลต้องการเอาต์พุตของเครื่องมือเพื่อสร้างการตอบสนองสุดท้าย หากคุณละขั้นตอนนี้ โมเดลอาจสร้างภาพลวงตาหรือให้คำตอบที่ไม่สมบูรณ์
ตรวจสอบให้แน่ใจว่าคำจำกัดความเครื่องมือของคุณชัดเจน มีชื่อและพารามิเตอร์ที่อธิบายได้ ทดสอบการเรียกใช้เครื่องมืออย่างละเอียดด้วยอินพุตต่างๆ เพื่อให้แน่ใจว่าโมเดลตีความและเรียกใช้ฟังก์ชันได้อย่างถูกต้อง สิ่งนี้สำคัญเป็นพิเศษเมื่อใช้โมเดลแบบเปิดน้ำหนักเช่น uncensored Qwen ซึ่งอาจมีการกระจายข้อมูลการฝึกที่แตกต่างกัน
ข้อผิดพลาดส่วนหัวการตรวจสอบสิทธิ์
การตรวจสอบสิทธิ์เป็นแนวป้องกันแรกสำหรับการเข้าถึง API ของคุณ ข้อผิดพลาดทั่วไปคือการใช้รูปแบบส่วนหัวผิด API ที่เข้ากันได้กับ OpenAI ส่วนใหญ่คาดหวังให้ส่วนหัวการตรวจสอบสิทธิ์มีรูปแบบเป็นAuthorization: Bearer YOUR_API_KEY การใช้ API-Key หรือรูปแบบอื่นอาจนำไปสู่ข้อผิดพลาด 401 Unauthorizedอีกปัญหาหนึ่งคือการส่งคีย์ API ในสตริงการค้นหาแทนที่จะเป็นส่วนหัว แม้ว่าจะมี API บางตัวที่รองรับสิ่งนี้ แต่มีความปลอดภัยน้อยกว่าและอาจไม่ทำงานกับไคลเอนต์ทั้งหมด ควรใช้วิธีการส่วนหัวเสมอเพื่อความปลอดภัยและความเข้ากันได้ที่ดีขึ้น
- ตรวจสอบรูปแบบส่วนหัว: ตรวจสอบรูปแบบส่วนหัวที่ต้องการในเอกสาร API อีกครั้ง
- การเก็บคีย์ API อย่างปลอดภัย: เก็บคีย์ API ในตัวแปรสภาพแวดล้อม ไม่ใช่ในโค้ด
- หมุนเวียนคีย์: สร้างคีย์ใหม่เป็นระยะเพื่อลดความเสี่ยงหากคีย์ถูกบุกรุก
การตรวจสอบสิทธิ์ที่เหมาะสมช่วยให้คำขอของคุณได้รับการจดจำและประมวลผลอย่างถูกต้อง หลีกเลี่ยงการลองซ้ำและข้อผิดพลาดที่ไม่จำเป็น
การแปลความหมายการตอบกลับข้อผิดพลาด
ข้อผิดพลาดของ API ให้เบาะแสที่มีคุณค่าสำหรับการแก้ไขข้อบกพร่อง แต่บ่อยครั้งมักถูกตีความผิด ข้อผิดพลาด 400 Bad Request มักบ่งชี้ถึงปัญหาในข้อมูลนำเข้า เช่น JSON ไม่ถูกต้องหรือขาดฟิลด์ที่จำเป็น ข้อผิดพลาด 401 Unauthorized ชี้ไปที่ปัญหาการตรวจสอบสิทธิ์ ในขณะที่ข้อผิดพลาด 429 Too Many Requests บ่งชี้ถึงการละเมิดขีดจำกัดอัตรา
อ่านข้อความข้อผิดพลาดอย่างละเอียด มักมีรายละเอียดเช่นฟิลด์ที่ทำให้เกิดข้อผิดพลาดหรือข้อจำกัดเฉพาะที่ละเมิด ตัวอย่างเช่น ข้อผิดพลาดอาจระบุว่า "Invalid value: 'function'" ซึ่งบ่งชี้ว่าฟิลด์ role ในข้อความไม่ถูกต้อง
บันทึกข้อผิดพลาดอย่างสม่ำเสมอและรวมบริบทเช่น payload ของคำขอและส่วนหัว ทำให้การจำลองและวินิจฉัยปัญหาในภายหลังง่ายขึ้น อย่าเพิกเฉยต่อข้อผิดพลาดชั่วคราว ให้ใช้ตรรกะการลองซ้ำพร้อมการหน่วงเวลาแบบทวีคูณเพื่อจัดการกับปัญหาเครือข่ายหรือเซิร์ฟเวอร์ชั่วคราว
