AI Prompt Engineering · บทเรียน

การทำความเข้าใจรั้วป้องกัน

ด่านควบคุมความปลอดภัยและคุณภาพ

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

คำจำกัดความของกลไกป้องกัน

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

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

เหตุใดการเขียนพรอมป์เพียงอย่างเดียวจึงไม่เพียงพอ

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

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

กลไกป้องกันขาเข้าและขาออก

ตำแหน่งสองแบบที่มีหน้าที่ต่างกัน:

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

การตรวจสอบขาเข้าช่วยประหยัดต้นทุน ส่วนการตรวจสอบขาออกช่วยปกป้องผู้ใช้

บล็อก, redact, สร้างใหม่, ยกระดับ

กลไกป้องกันต้องตัดสินใจว่าจะทำอะไรเมื่อพบการละเมิด:

บล็อก — ปฏิเสธและส่งคืนข้อความที่ปลอดภัย
redact — ลบช่วงข้อความที่เป็นปัญหาแล้วทำงานต่อ
สร้างใหม่ — ส่งพรอมป์ใหม่พร้อมระบุการละเมิด
ยกระดับ — ส่งต่อให้มนุษย์หรือรุ่นที่เข้มงวดกว่า

การกระทำที่เหมาะสมขึ้นอยู่กับความรุนแรงและความไว้วางใจของผู้ใช้

def on_violation(severity):
    if severity == 'critical': return 'block'
    if severity == 'pii': return 'redact'
    if severity == 'quality': return 'regenerate'
    return 'escalate'

กระบวนการกลไกป้องกัน

ประกอบกลไกป้องกันเป็นกระบวนการตามลำดับ และหยุดทันทีเมื่อพบการละเมิดร้ายแรงครั้งแรก

def guarded_generate(user_input):
    for g in INPUT_GUARDS:
        verdict = g.check(user_input)
        if verdict.block:
            return safe_refusal(verdict)
    output = call_model(user_input)
    for g in OUTPUT_GUARDS:
        verdict = g.check(output)
        if verdict.block:
            return verdict.handle(output)
    return output

กลไกป้องกันแบบกำหนดแน่นอนเทียบกับแบบอิงรุ่น

รูปแบบการนำไปใช้งานสองแบบ:

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

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

งบประมาณเวลาแฝงและต้นทุน

กลไกป้องกันทุกตัวเพิ่มเวลาแฝง กลยุทธ์เพื่อให้ทำงานได้รวดเร็วมีดังนี้:

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

verdicts = await asyncio.gather(*[g.check(out) for g in OUTPUT_GUARDS])
if any(v.block for v in verdicts):
    return handle(verdicts)

ผลบวกลวงมีต้นทุนจริง

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

การสตรีมทำให้การตรวจสอบผลลัพธ์ซับซ้อนขึ้น

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

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

เลือกวิธีตามความเสียหายที่ผลลัพธ์บางส่วนซึ่งรั่วไหลอาจก่อให้เกิดขึ้น

ความสามารถในการตรวจสอบย้อนหลังและการบันทึก

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

audit.log({'guard': g.id, 'verdict': verdict.label,
           'action': verdict.action, 'input_hash': sha256(inp)})

กลไกป้องกันไม่ใช่สิ่งทดแทนการออกแบบ

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

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

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

สรุปทบทวน

พื้นฐานของกลไกป้องกัน:

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

ถัดไป: การกรองข้อมูลขาเข้าและขาออกเชิงลึก

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

บทเรียน “การทำความเข้าใจรั้วป้องกัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การทำความเข้าใจรั้วป้องกัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การทำความเข้าใจรั้วป้องกัน” ใช้เวลานานแค่ไหน

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

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

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

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

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