TH ▾

unfilteredaiapi.comhttps://api.unfilteredaiapi.com/v1

Unfiltered AI

API LLM แบบไม่เซ็นเซอร์สำหรับนักพัฒนา

Unfiltered AIรับคีย์ API

ความจำการสนทนาในหน้าต่าง 100k: การจัดสรร การตัด และบทสรุป

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

ความจำการสนทนาในหน้าต่าง 100k: การจัดสรร การตัด และบทสรุป

จุดสำคัญ

  • ผู้ให้บริการอนุมานเฉพาะทางเช่น Unfiltered AI เสนอพฤติกรรมที่ไม่เซ็นเซอร์ที่สม่ำเสมอบนโมเดลเดียว หลีกเลี่ยงความสุ่มจากการจัดเส้นทางโดยตัวรวม
  • ตัวรวมเช่น OpenRouter ให้การเข้าถึงโมเดลหลายตัวแต่อาจมีความแตกต่างในการใช้ตัวกรองเนื้อหาอย่างเคร่งครัด ขึ้นอยู่กับเวอร์ชันโมเดลเฉพาะ
  • Unfiltered AI ใช้โมเดลแบบเปิดน้ำหนักบนฮาร์ดแวร์เฉพาะทางพร้อมหน้าต่างบริบท 100k ในราคา $0.15/$0.50 ต่อหนึ่งล้านโทเคน
  • สำหรับ NSFW ที่เข้มงวดหรือความสม่ำเสมอของการสวมบทบาท API LLM ที่ไม่เซ็นเซอร์เฉพาะทางจะกำจัดความจำเป็นในการวิศวกรรมพรอมต์ที่ซับซ้อนเพื่อข้ามตัวกรองทั่วไป

คิดว่าหน้าต่างเป็นบัญชีแยกประเภท

โมเดลไม่มีหน่วยความจำระหว่าง call สิ่งที่ดูเหมือนการจดจำคือคุณส่งข้อความซ้ำ และทุก token ที่ส่งซ้ำจะเพิ่มในบัญชีที่มีเพดานตายตัว: 100,000 tokens ซึ่งใช้ร่วมกันระหว่าง prompt and การตอบกลับ หากใช้ prompt มากขึ้น พื้นที่สำหรับคำตอบก็จะลดลง และหากขอทั้งสองฝ่ายมากเกินไป request จะถูกปฏิเสธด้วย 400

บัญชีแยกประเภทที่ใช้งานได้มีลักษณะดังนี้ สำรอง 1,500 โทเคนสำหรับการตอบกลับ เพราะนั่นคือสิ่งที่คุณจะส่งเป็น max_tokens สำรองอีก 3,000 เป็นขอบเขตความปลอดภัย เนื่องจากจำนวนโทเคนในเครื่องใดๆ เป็นการประมาณการ นั่นทำให้เหลือโทเคนงบประมาณ 59,500 สำหรับพรอมต์ ภายในงบประมาณนั้น เนื้อหาสี่ประเภทแข่งขันกัน: พรอมต์ระบบ ข้อเท็จจริงที่ตรึง บทสรุปแบบหมุนเวียน และการสนทนาล่าสุดแบบตรงตัว ส่วนที่เหลือของบทความนี้เกี่ยวกับการตัดสินใจว่าใครชนะ

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

การนับโดยไม่ใช้ tokenizer

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

นั่นคือเหตุผลที่มีขอบเขต และทำไมการปรับเทียบจึงคุ้มค่า หลังจากแต่ละการเรียกใช้ ให้เปรียบเทียบจำนวนตัวอักษรที่คุณส่งกับ usage.prompt_tokens และปรับอัตราส่วนของคุณเข้าหาค่าที่สังเกตได้ ปัจจัยการปรับแต่งเล็กน้อยช่วยรักษาข้อความแปลกๆ หนึ่งข้อความไม่ให้เบี่ยงเบนค่า

class Calibrator:
    """Learns the real chars-per-token ratio from the usage block."""
    def __init__(self):
        self.ratio = 4.0

    def update(self, sent_messages, prompt_tokens):
        chars = sum(len(m["content"]) for m in sent_messages)
        if prompt_tokens > 0 and chars > 2000:
            observed = chars / prompt_tokens
            self.ratio = 0.8 * self.ratio + 0.2 * observed   # smooth it

    def est(self, text):
        return int(len(text) / self.ratio) + 4

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

การตัด: เริ่มจากใหม่สุด ไม่ตัดกลางคู่

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

# memory.py
WINDOW = 64_000      # prompt + completion share this
MAX_OUT = 1_500      # what we ask for in max_tokens
MARGIN = 3_000       # slack for estimation error
BUDGET = WINDOW - MAX_OUT - MARGIN   # 59,500 tokens for the prompt

def est_tokens(text: str) -> int:
    # Rough heuristic: about 4 characters per token for English prose.
    return len(text) // 4 + 4

def build_messages(system, pinned, summary, turns):
    """Return (messages_to_send, dropped_turns). turns is oldest-first."""
    head = [{"role": "system", "content": system}]
    if pinned:
        head.append({"role": "system", "content": "Pinned facts (always true):\n- " + "\n- ".join(pinned)})
    if summary:
        head.append({"role": "system", "content": "Story so far: " + summary})

    used = sum(est_tokens(m["content"]) for m in head)
    kept = []
    for m in reversed(turns):                  # walk from the newest turn backwards
        cost = est_tokens(m["content"])
        if used + cost > BUDGET:
            break
        kept.append(m)
        used += cost
    kept.reverse()
    while kept and kept[0]["role"] != "user":  # never start on an orphaned assistant turn
        kept.pop(0)
    dropped = turns[: len(turns) - len(kept)]
    return head + kept, dropped

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

การตรึงข้อเท็จจริงที่ต้องคงอยู่

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

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

เก็บ block ที่ pin ไว้ให้เหลือประมาณ 400 tokens หากเกินกว่านั้น โมเดลจะเริ่มทำงานเหมือน system prompt สองชุด และเริ่ม treat ทุกบรรทัดที่ pin ไว้ว่ามีความเร่งด่วนเท่ากัน ควรตรวจสอบรายการเป็นระยะและลบข้อเท็จจริงที่ไม่ตรงกับความเป็นจริงแล้วออก

บทสรุปแบบหมุนเวียน

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

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.unfilteredaiapi.com/v1", api_key=os.environ["API_KEY"])

SUMMARY_PROMPT = (
    "Compress the material below into a running summary of at most 250 words. "
    "Keep: who is present, what changed, promises and secrets, unresolved threads, "
    "the current location and mood. Drop: filler and repeated description. "
    "Write plain past-tense prose, no bullet points."
)

def fold_into_summary(old_summary, dropped_turns):
    transcript = "\n".join(f"{m['role']}: {m['content']}" for m in dropped_turns)
    user = f"Existing summary:\n{old_summary or '(none)'}\n\nNew material:\n{transcript}"
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "system", "content": SUMMARY_PROMPT}, {"role": "user", "content": user}],
        temperature=0.2,
        max_tokens=450,
    )
    return r.choices[0].message.content.strip()

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

การนำชิ้นส่วนต่างๆ มาประกอบกัน

class ด้านล่างเชื่อมการ trim, pin และ summarising เข้าด้วยกันใน loop แต่ละ call จะสร้าง prompt, ตรวจสอบว่ามีการ drop อะไรหรือไม่, fold เข้าใน summary หากมี และสร้างใหม่ กฎนี้ตั้งใจให้เป็นแบบ lazy: จะทำเฉพาะเมื่อ window บังคับเท่านั้น ดังนั้นการสนทนาสั้นๆ จึงไม่ต้องเสียเวลาเรียก summary

from memory import build_messages, fold_into_summary, client, MAX_OUT

class Conversation:
    def __init__(self, system, pinned):
        self.system, self.pinned = system, pinned
        self.summary, self.turns = "", []

    def say(self, text):
        self.turns.append({"role": "user", "content": text})
        messages, dropped = build_messages(self.system, self.pinned, self.summary, self.turns)
        if dropped:                                   # something fell out of the window
            self.summary = fold_into_summary(self.summary, dropped)
            self.turns = self.turns[len(dropped):]
            messages, _ = build_messages(self.system, self.pinned, self.summary, self.turns)
        r = client.chat.completions.create(
            model="uncensored", messages=messages, max_tokens=MAX_OUT, temperature=0.8
        )
        answer = r.choices[0].message.content
        self.turns.append({"role": "assistant", "content": answer})
        return answer

convo = Conversation(
    system="You narrate a slow-burn adult mystery set in a mountain hotel.",
    pinned=["Ines Duarte is the night manager and is lying about the ledger.",
            "It is the third night of the blizzard; the road is closed.",
            "The narrator never reveals the culprit before the player accuses someone."],
)
print(convo.say("I ask Ines why the guest book has a page missing."))

สิ่งนี้เข้าคู่ได้ตามธรรมชาติกับรีเลย์สตรีมมิงใน บทความแบ็กเอนด์ FastAPI ที่ที่ที่เก็บเซสชันจะเก็บ summary, pinned และ turns แทนรายการแบนเดียว สำหรับสถานะ NPC ที่มีโครงสร้างในรูปแบบเดียวกัน ดู คู่มือบทสนทนาเกม

ต้นทุนของการจดจำ

Long memory ไม่ได้ฟรี เพราะ prompt ทั้งหมดจะถูกคิดค่าใช้จ่ายอีกครั้งในทุก call ให้สมมติสอง setup ในแบบแรก history อนุญาตให้เติม 50,000 prompt tokens และแต่ละ reply คือ 500 tokens ค่า input คือ 50,000 x $0.15 / 1,000,000 = $0.0075 ค่า output คือ 500 x $0.50 / 1,000,000 = $0.00025 ดังนั้นแต่ละ turn มีค่าใช้จ่ายประมาณ $0.00775 ในแบบที่สอง คุณเก็บ 8,000 tokens ของการสนทนาล่าสุด plus summary 600 tokens และ pinned tokens 400 tokens รวมประมาณ 9,000 tokens ค่า input คือ $0.00225 ค่า output คือ $0.00025 ดังนั้นแต่ละ turn มีค่าใช้จ่ายประมาณ $0.0028

เมื่อทำเกิน 1,000 turns ค่าใช้จ่ายจะอยู่ที่ประมาณ $13 เทียบกับ $2.75 ภายใต้สมมติฐานเหล่านี้ วิธีการ summary ยังต้องเรียก call เพิ่มเติมเป็นครั้งคราวด้วย input 3,000 tokens และ output 450 tokens ซึ่งคิดเป็นประมาณ $0.0012 ซึ่งน้อยมากเมื่อเทียบกับความประหยัด อัตราอยู่ที่ หน้าราคา

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

จุดที่แผนความจำล้มเหลวอย่างเงียบๆ

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

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

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

ถาม-ตอบ

เกิดอะไรขึ้นหากพรอมต์รวมกับ max_tokens เกิน 100,000?

การร้องขอไม่ถูกปฏิเสธ: max_tokens จะถูกปรับให้เหลือพื้นที่ที่มีอยู่ในหน้าต่าง และคำตอบจะหยุดที่ขอบเขตของหน้าต่าง การส่ง prompt ที่ยาวกว่า 100,000 tokens เท่านั้นที่จะทำให้เกิดข้อผิดพลาด 400 bad request

ฉันสามารถนับโทเคนได้อย่างแม่นยำก่อนคำขอหรือไม่?

ไม่สามารถทำได้ล่วงหน้าอย่างแม่นยำ ประมาณการในเครื่อง รักษาขอบความปลอดภัย และปรับเทียบกับค่า usage.prompt_tokens ที่ส่งกลับมาพร้อมแต่ละการตอบกลับ

ฉันควรสรุปบ่อยแค่ไหน?

เฉพาะเมื่อจำนวนรอบการสนทนาเกินหน้าต่างบริบท การทำเช่นนี้ช่วยให้การสนทนาสั้นๆ ไม่มีการเรียก API ที่ไม่จำเป็น

ข้อเท็จจริงที่ตรึงและบทสรุปมีการเรียกเก็บเงินหรือไม่?

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

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

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

รับคีย์ APIอ่านเอกสาร