AI Prompt Engineering · บทเรียน

การแคชคำนำหน้ายาว

ควบคุมต้นทุนด้วยการแคชพรอมต์

บทเรียน 4 จาก 413 ขั้นตอน

การแคชคำนำหน้ายาว เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

เหตุผลที่มีการแคชคำนำหน้า

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

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

การแคชยึดกับคำนำหน้า

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

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

# Cache reuse covers: [identical prefix .... first difference)
# One early edit invalidates the whole downstream cache.

เรียงตามความคงที่

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

คงที่ -> ด้านหน้า (แคชได้)
เปลี่ยนแปลงได้ -> ด้านหลัง (เป็นส่วนเดียวที่ต้องประมวลผลใหม่)

หลักการเรียงลำดับเพียงข้อนี้เป็นตัวขับเคลื่อนประโยชน์ส่วนใหญ่จากการแคช

prompt = [
  SYSTEM_RULES,        # never changes
  TOOL_SPECS,          # rarely changes
  REFERENCE_CORPUS,    # stable for the session
  USER_TURN            # changes every call -> keep last
]

จุดแบ่งแคช

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

หากไม่มีเครื่องหมายที่ชัดเจน ให้จัดโครงสร้างตามลำดับความคงที่อยู่ดี เพื่อให้การจับคู่คำนำหน้าโดยนัยยังช่วยได้

blocks = [
  {'text': SYSTEM_RULES, 'cache': True},
  {'text': REFERENCE_CORPUS, 'cache': True},  # big win
  {'text': user_turn}  # uncached
]

ระวังคำนำหน้าเปลี่ยนแปลงโดยซ่อนเร้น

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

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

# BAD: dynamic value early -> kills cache
# system = 'Session ' + str(uuid4()) + ' rules: ...'
# GOOD: keep system static; put the id in the tail user turn.

TTL และอายุการใช้งานแคช

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

จับคู่รูปแบบปริมาณการใช้งานของคุณกับ TTL และพิจารณาส่งสัญญาณคงการเชื่อมต่อสำหรับคำนำหน้าที่มีคุณค่า

แบบจำลองต้นทุนของการแคช

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

มีการนำกลับมาใช้ซ้ำสูง -> ให้แคชอย่างเต็มที่
คำนำหน้าที่ใช้ครั้งเดียว -> การแคชอาจไม่คุ้มค่า

def worth_caching(prefix_tokens, expected_reuses, write_mult, read_mult):
    no_cache = expected_reuses
    cached = write_mult + read_mult * (expected_reuses - 1)
    return cached < no_cache  # in normalized prefix-cost units

การออกแบบบล็อกระบบที่เสถียร

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

ให้ถือว่าคำนำหน้าที่แคชไว้เป็นชิ้นงานที่มีเวอร์ชัน ไม่ใช่ข้อความที่ปรับแก้ตามอำเภอใจ

TOOLS = sorted(tool_defs, key=lambda t: t['name'])  # canonical order
SYSTEM_VERSION = 'v3'  # change deliberately, not per request

การแคชในเอเจนต์หลายรอบ

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

เมื่อจำเป็นต้องย่อบทสนทนา ให้ดำเนินการในลักษณะที่สร้างคำนำหน้าใหม่ที่เสถียรสำหรับรอบถัดไป แทนการแก้ไขคำนำหน้าเดิมซ้ำ ๆ

การวัดประสิทธิผลของแคช

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

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

hit_rate = usage['cache_read_input_tokens'] / max(1, usage['input_tokens'])
assert hit_rate > 0.6, 'prefix drift suspected'

โครงสร้างพรอมต์ที่คำนึงถึงการแคช

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

ตรวจสอบอย่างรวดเร็ว

คุณนำคลังข้อมูลอ้างอิงขนาด 100,000 โทเค็นกลับมาใช้ซ้ำกับคำถามหลายพันรายการต่อวัน แต่อัตราการเข้าถึงแคชสำเร็จของคุณเกือบเป็นศูนย์

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวน: การแคชคำนำหน้ายาว

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

เริ่มต้นได้ฟรี

เรียนรู้ AI Prompt Engineering ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 53
บทเรียน: 199

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “การแคชคำนำหน้ายาว” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การแคชคำนำหน้ายาว” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Prompt Engineering ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การแคชคำนำหน้ายาว”

ควบคุมต้นทุนด้วยการแคชพรอมต์ คุณปฏิบัติ AI Prompt Engineering ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Prompt Engineering หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Prompt Engineering บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การแคชคำนำหน้ายาว” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม

ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ AI Prompt Engineering