TH ▾

Uncensored Model Hubmodel_context_window_exceeded: สาเหตุและการแก้ไข

model_context_window_exceeded: สาเหตุและการแก้ไข

ข้อผิดพลาดหน้าต่างบริบทหมายถึงพรอมต์ของคุณรวมกับคำตอบที่คุณขอไม่พอดีกับความจำของโมเดล บทความนี้อธิบายขีดจำกัดของ API นี้ (100,000 โทเคน) วิธีวัดพรอมต์ของคุณ และโค้ดที่ตัดประวัติก่อนเกิดข้อผิดพลาด

อัปเดต

ภาชนะแก้วเต็มไปด้วยบล็อกเรืองแสง ซึ่งถูกตัดส่วนเกินออก แทนถึงหน้าต่างบริบทที่เต็ม

ประเด็นสำคัญ

  1. หน้าต่างมีขนาด 100,000 โทเคน และนับรวมพรอมต์และการสร้างข้อความ
  2. แอปแชทมักเกิดปัญหานี้เพราะส่งประวัติทั้งหมดในทุกเทิร์น
  3. นับหรือประมาณการโทเคนก่อนส่ง และสำรองพื้นที่สำหรับคำตอบ
  4. การตัดเทิร์นเก่ายังช่วยลดต้นทุน เนื่องจากอินพุตคิดเงินที่ $0.15 ต่อ 1M โทเคน

ความหมายของ 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 หมายถึงการโอเวอร์โหลดชั่วคราว รายการใน เอกสารประกอบ ระบุฟิลด์คำขอ, บทอธิบายเรื่องโมเดลแบบไม่เซ็นเซอร์ ครอบคลุมว่าโมเดลคืออะไร, และคุณสามารถ รับคีย์ เพื่อทดสอบสิ่งเหล่านี้ด้วยจำนวนการใช้งานจริง

ถาม-ตอบ

ฉันส่งโทเคนได้กี่ตัวในหนึ่งคำขอ?

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

ฉันจะถูกเรียกเก็บเงินเมื่อคำขอเกินหน้าต่างบริบทหรือไม่?

ไม่ คำขอที่ล้มเหลวจะไม่ถูกเรียกเก็บเงิน คุณจ่ายตามโทเคนเฉพาะสำหรับคำขอที่เสร็จสมบูรณ์เท่านั้น

ฉันต้องตั้งค่า max_tokens หรือไม่?

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

ฉันจะนับโทเคนได้อย่างแม่นยำอย่างไร?

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

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API