ความหมายของ model_context_window_exceeded
สตริง model_context_window_exceeded เป็นวิธีที่ไคลเอนต์ SDK และ API บางตัวระบุความล้มเหลวเฉพาะอย่างหนึ่ง: ข้อความที่คุณส่งรวมกับพื้นที่ที่ต้องการสำหรับคำตอบ มีขนาดใหญ่กว่าที่โมเดลจะรองรับได้ในคำขอเดียว รูปแบบข้อความอาจแตกต่างกันไปในแต่ละเครื่องมือ ดังนั้นควรอ่านรายละเอียดข้อผิดพลาดที่ไคลเอนต์แสดงแทนการพึ่งพาชื่อเสมอ สาเหตุหลักมาจากสิ่งเดียวกัน
หน้าต่างบริบทของ API นี้มีขนาด 100,000 โทเคน ซึ่งครอบคลุมทั้งพรอมต์และการสร้างผลลัพธ์รวมกัน หากพรอมต์ของคุณใช้ 95,000 โทเคน พื้นที่สำหรับคำตอบจะเหลือประมาณ 5,000 โทเคน หากคุณตั้งค่า max_tokens เป็น 8,000 คำตอบจะหยุดที่ท้ายหน้าต่างโดยมีไม่ถึง 8,000 โทเคน ฟิลด์ max_tokens เป็นตัวเลือก หากไม่ระบุ ระบบจะตอบโดยใช้พื้นที่ที่เหลือทั้งหมด
คำขอที่ล้มเหลวด้วยวิธีนี้จะส่งข้อผิดพลาดแทนการสร้างคำตอบ คำขอที่ล้มเหลวจะไม่ถูกเรียกเก็บเงิน ดังนั้นการชนขีดจำกัดจึงไม่เสียค่าใช้จ่ายใด ๆ นอกจากค่าการส่ง-รับข้อมูล วิธีแก้ไขอยู่ฝั่งของคุณ: ส่งข้อมูลน้อยลง หรือขอคำตอบที่สั้นลง
100,000 โทเคน มีขนาดใหญ่มากแค่ไหน?
โทเคนคือส่วนของข้อความ ซึ่งมักจะเป็นคำสั้นๆ หรือส่วนหนึ่งของคำที่ยาวกว่า สำหรับงานเขียนภาษาอังกฤษทั่วไป กฎโดยประมาณคือหนึ่งโทเคนต่อสี่ตัวอักษร หรือประมาณสามในสี่ของคำ ตามกฎนี้ 100,000 โทเคน มีขนาดประมาณ 75,000 คำ ซึ่งเทียบเท่าหนังสือหนาเล่มหนึ่ง โค้ด JSON ตาราง และข้อความที่ไม่ใช่ภาษาอังกฤษจะแบ่งออกเป็นโทเคนต่อตัวอักษรมากกว่า ดังนั้นจำนวนตัวอักษรเท่ากันอาจใช้โทเคนมากกว่านี้ ให้ถือว่ากฎโดยประมาณนี้เป็นตัวเลขสำหรับการวางแผน ไม่ใช่การรับประกัน
จำนวนที่แน่นอนมาจากตัวแบ่งคำ (tokenizer) ของโมเดล API จะรายงานการใช้งานจริงในการตอบกลับ: ออบเจ็กต์ usage จะระบุจำนวนโทเคนของพรอมต์และการสร้างคำตอบ และคำตอบแบบสตรีมมิงจะส่งข้อมูลการใช้งานที่ท้ายสุด นั่นคือข้อมูลที่เชื่อถือได้ที่สุดที่คุณมี ดังนั้นจงบันทึกข้อมูลนั้น
| เนื้อหา | ขนาดโดยประมาณ |
|---|---|
| ข้อความแชทสองประโยค | 40 ถึง 60 โทเคน |
| ข้อความหนึ่งหน้าของภาษาอังกฤษ จำนวน 500 คำ | ประมาณ 670 โทเคน |
| เอกสารยาว 10,000 คำ | ประมาณ 13,000 โทเคน |
| ไฟล์ JSON dump ขนาด 3 MB | มักเกิน 100,000 โทเคน ซึ่งใหญ่เกินกว่าจะส่งแบบดิบได้ |
ส่วนเนื้อหา (request body) มีขีดจำกัดขนาด 8 MB ซึ่งเป็นขีดจำกัดแยกจากโทเคน อินพุตขนาดใหญ่อาจล้มเหลวจากข้อจำกัดใดข้อจำกัดหนึ่ง และขีดจำกัดโทเคนมักเป็นข้อจำกัดแรกที่คุณจะพบ
เหตุผลที่แอปแชทชนขีดจำกัด
API ไม่มีความจำระหว่างการเรียกใช้งาน หากต้องการสนทนาต่อ โค้ดของคุณต้องส่งรายการข้อความทั้งหมดทุกครั้ง ทุกเทิร์นจะเพิ่มข้อความผู้ใช้และคำตอบเข้าไป ทำให้พรอมต์ยาวขึ้นทุกครั้งที่มีการแลกเปลี่ยน บอทที่ทำงานได้ดีเป็นเวลาหนึ่งชั่วโมงแล้วเริ่มล้มเหลว เป็นสัญญาณคลาสสิกของปัญหานี้
สิ่งเดียวกันนี้เกิดขึ้นในเอเยนต์ ผลลัพธ์ของเครื่องมือทุกชิ้นจะถูกเพิ่มเข้าไปในประวัติ และฟังก์ชันที่ส่งกลับบันทึกขนาดใหญ่สามารถเพิ่มโทเคนหลายพันตัวในขั้นตอนเดียว การตั้งค่า Retrieval เพิ่มแหล่งข้อมูลอีกแหล่งหนึ่ง: หากคุณวางชิ้นส่วนเอกสารยี่สิบชิ้นลงในแต่ละพรอมต์ ต้นทุนพื้นฐานต่อคำขอจะสูงอยู่แล้วก่อนที่ประวัติใดๆ จะเกิดขึ้น
ก่อนจะแก้ไขสิ่งใด ให้หาสาเหตุที่เพิ่มขึ้นจากสามสาเหตุนี้ พิมพ์จำนวนโทเคนของพรอมต์จาก usage หลังการเรียกใช้งานทุกครั้ง หากจำนวนเพิ่มขึ้นในปริมาณที่เท่ากันทุกเทิร์น แสดงว่าเป็นปัญหาจากประวัติ หากจำนวนเพิ่มขึ้นหลังจากขั้นตอนเฉพาะ แสดงว่าเป็นปัญหาจากผลลัพธ์เครื่องมือหรือข้อความที่ดึงมา
ตัดประวัติออกก่อนส่ง
วิธีแก้ไขที่ง่ายและเชื่อถือได้ที่สุดคือฟังก์ชันที่ตัดเทิร์นที่เก่าที่สุดออกจนกว่าการประมาณการจะอยู่ในงบประมาณที่กำหนด เก็บข้อความระบบไว้เสมอ และเก็บข้อความผู้ใช้ล่าสุดไว้เสมอ งบประมาณควรเหลือพื้นที่สำหรับคำตอบ ดังนั้นให้ใช้ประมาณ 80,000 โทเคนสำหรับพรอมต์ และปล่อยให้ส่วนที่เหลือเป็นพื้นที่สำหรับคำตอบ
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
)
def estimate_tokens(text: str) -> int:
return len(text) // 4 + 4 # rough: 4 characters per token plus overhead
def trim(messages, budget=80_000):
system = [m for m in messages if m["role"] == "system"]
rest = [m for m in messages if m["role"] not in ("system",)]
total = sum(estimate_tokens(m["content"]) for m in system + rest)
while total > budget and len(rest) > 1:
dropped = rest.pop(0) # oldest turn goes first
total -= estimate_tokens(dropped["content"])
return system + rest
history = [{"role": "system", "content": "You are a helpful assistant."}]
def ask(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(
model="uncensored",
messages=trim(history),
max_tokens=2000,
)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
return reply
เก็บการสนทนาของผู้ใช้และผู้ช่วยเป็นคู่เมื่อทำได้; การทิ้งครึ่งหนึ่งของคู่หนึ่งอาจทำให้โมเดลสับสน ข้อความของเครื่องมือก็คล้ายกัน: ข้อความที่มี role: "tool" ต้องอยู่กับรอบของผู้ช่วยที่ขอมัน ดังนั้นจึงควรทิ้งทั้งคู่ไปพร้อมกัน เนื่องจากประมาณการเป็นค่าประมาณ ช่วงห่าง 20 เปอร์เซ็นต์ระหว่างงบประมาณของคุณกับหน้าต่างบริบทจริงถือเป็นขอบเขตความปลอดภัยที่สบาย
ตัวเลือกที่ดีกว่าการตัดเทิร์นเก่า
สรุป แล้วดำเนินการต่อ
เมื่อประวัติการสนทนาเกินเกณฑ์ที่กำหนด ให้ส่งครึ่งหนึ่งของเทิร์นที่เก่าที่สุดไปยังโมเดลพร้อมคำสั่งให้สรุปข้อความนั้นในไม่กี่ร้อยคำ จากนั้นแทนที่เทิร์นเหล่านั้นด้วยข้อความสรุปเป็นข้อความระบบหรือข้อความผู้ใช้ คุณอาจเสียรายละเอียดแต่ยังคงเส้นเรื่องไว้ ดำเนินการขั้นตอนนี้ภายนอกเส้นทางการตอบกลับแบบเรียลไทม์ เพื่อให้ผู้ใช้ไม่ต้องรอ
ตรึงข้อเท็จจริงที่ต้องคงอยู่
เก็บบล็อกข้อความขนาดเล็กที่ทนทาน เช่น ชื่อ การตัดสินใจ และการตั้งค่า แล้วนำกลับไปวางไว้ที่ด้านบนของทุกคำขอ วิธีนี้ดีกว่าการหวังว่าข้อความเก่าจะยังอยู่ในหน้าต่างบริบท
ลดปริมาณข้อมูลที่ป้อนเข้า
ตัดผลลัพธ์ของเครื่องมือให้เหลือเฉพาะฟิลด์ที่สำคัญ ดึงข้อมูลเป็นชิ้นส่วนน้อยลง และตัดแต่ละชิ้นให้เหลือเฉพาะย่อหน้าที่เกี่ยวข้อง สำหรับเอกสารที่ยาวมาก ให้แบ่งออกเป็นหลายส่วน ประมวลผลแต่ละส่วน แล้วรวมผลลัพธ์ในคำขอสุดท้ายที่สั้นลง
ตั้งค่า max_tokens อย่างมีเจตนา
หากคำตอบโดยปกติจะสั้น ให้จำกัด max_tokens ที่ค่าที่เหมาะสมกับผลิตภัณฑ์ของคุณ การจำกัดช่วยป้องกันงบประมาณ แต่การจำกัดที่ต่ำเกินไปอาจตัดการตอบกลับกลางประโยค ดังนั้นให้ตรวจสอบความยาวของคำตอบจริงในบันทึกก่อน
การตัดทอนยังช่วยประหยัดเงิน
โทเคนอินพุตมีราคา $0.15 ต่อ 1M โทเคน โทเคนเอาต์พุต $0.50 ต่อ 1M โดยหักจากเครดิตแบบเติมเงินล่วงหน้า เนื่องจากแชทส่งประวัติซ้ำทุกครั้ง ต้นทุนต่อการสนทนาจึงเพิ่มขึ้นเร็วกว่าความยาว ลองพิจารณาแชทที่มีการแลกเปลี่ยนแต่ละครั้งเพิ่ม 500 โทเคนเข้าสู่ประวัติ และการสนทนาดำเนินไป 100 รอบ
- หากไม่มีการตัดทอน รอบที่ n จะส่ง 500 x n โทเคน ผลรวมตลอด 100 รอบคือ 500 x 5,050 = 2,525,000 โทเคนอินพุต ซึ่งคิดเป็น 2.525 x $0.15 = $0.379
- หากใช้ขีดจำกัด 20,000 โทเคน 40 รอบแรกจะเหมือนกัน (500 x 820 = 410,000 โทเคน) 60 รอบที่เหลือจะส่ง 20,000 โทเคนต่อรอบ ซึ่งคิดเป็น 1,200,000 โทเคน รวมเป็น 1,610,000 โทเคน หรือ 1.61 x $0.15 = $0.242
ขีดจำกัดนี้ช่วยประหยัดได้ประมาณหนึ่งในสาม และช่องว่างนี้จะกว้างขึ้นเมื่อแชทยาวขึ้น ในกรณีสุดขั้ว พรอมต์ขนาด 100,000 โทเคนมีต้นทุน 0.1 x $0.15 = $0.015 ต่อคำขอ ซึ่งถูกมากเมื่อคิดแยกกัน แต่จะสะสมเมื่อบอทให้บริการผู้ใช้จำนวนมาก รายละเอียดราคาและโบนัสการเติมเงินอยู่ที่ หน้าราคา และเครดิตไม่หมดอายุ
การจัดการข้อผิดพลาดในโค้ด
แม้จะมีการตัดทอน ก็ควรเตรียมการสำหรับความล้มเหลว จับข้อผิดพลาดจาก API ตรวจสอบว่าข้อความชี้ไปที่ความยาวของหน้าต่างบริบทหรือไม่ ลดขนาดคำขอ แล้วลองใหม่หนึ่งครั้ง อย่าลองคำขอเดิมซ้ำ เนื่องจากจะล้มเหลวด้วยวิธีเดียวกัน
from openai import BadRequestError
def safe_ask(messages, budget=80_000):
try:
return client.chat.completions.create(
model="uncensored", messages=trim(messages, budget)
)
except BadRequestError as err:
if "context" in str(err).lower() and budget > 10_000:
return safe_ask(messages, budget // 2)
raise
ตรวจสอบรหัสสถานะและข้อความจริงที่ไคลเอนต์ของคุณได้รับสำหรับคำขอที่มีขนาดใหญ่เกินไป และปรับการทดสอบ; การจับคู่สตริงด้านบนเป็นเพียงจุดเริ่มต้น ขีดจำกัดอัตราเป็นอิสระ: HTTP 429 พร้อม rate_limited หรือ concurrency หมายถึงคำขอมากเกินไป ไม่ใช่โทเคนมากเกินไป และ 429 พร้อม Retry-After: 5 หมายถึงการโอเวอร์โหลดชั่วคราว รายการใน เอกสารประกอบ ระบุฟิลด์คำขอ, บทอธิบายเรื่องโมเดลแบบไม่เซ็นเซอร์ ครอบคลุมว่าโมเดลคืออะไร, และคุณสามารถ รับคีย์ เพื่อทดสอบสิ่งเหล่านี้ด้วยจำนวนการใช้งานจริง
