แบบผสม: พรอมต์และการปรับแต่งเล็กน้อย
การผสานทั้งสองแนวทาง
แบบผสม: พรอมต์และการปรับแต่งเล็กน้อย เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน
แนวคิดแบบผสม
การใช้พรอมป์ต์และการปรับแต่งละเอียดไม่ใช่คู่แข่งกัน แต่เป็น ชั้นการทำงาน รูปแบบที่ผู้เชี่ยวชาญใช้คือโมเดลที่ปรับแต่งเพียงเล็กน้อยเพื่อจัดการพฤติกรรมที่คงที่และเรียนรู้ไว้แล้ว แล้วครอบด้วยพรอมป์ต์บาง ๆ ที่เติมบริบทซึ่งเปลี่ยนแปลงได้และเฉพาะต่อคำขอแต่ละครั้ง
- การปรับแต่งละเอียดรองรับสิ่งที่ คงที่: รูปแบบ น้ำเสียง และกรอบของงาน
- การใช้พรอมป์ต์เติมสิ่งที่ เปลี่ยนแปลงได้: คำสั่ง ข้อเท็จจริงที่ดึงมาใช้ และสถานะของผู้ใช้
- แต่ละชั้นทำหน้าที่ที่ตนเองถนัดที่สุด และไม่มีชั้นใดต้องแบกรับภาระทั้งหมด
การแยกส่วนคงที่เทียบกับผันผวน
ทักษะหลักของระบบไฮบริดคือการแยกพฤติกรรมตามแกน คงที่/ผันผวน สิ่งใดก็ตามที่เหมือนกันในทุกการเรียกใช้และมีค่าใช้จ่ายสูงหากต้องใส่ซ้ำในพรอมป์ สิ่งนั้นเหมาะสำหรับการปรับแต่ง ส่วนสิ่งที่เปลี่ยนแปลงไปในแต่ละครั้งต้องคงไว้ในพรอมป์
หากแยกส่วนผิดไปในทิศทางใดทิศทางหนึ่ง คุณจะเสียประโยชน์ทันที หากฝังเนื้อหาที่ผันผวนไว้ในน้ำหนัก คุณจะต้องปรับแต่งใหม่เมื่อต้องการเปลี่ยนเนื้อหานั้น แต่หากเก็บเนื้อหาคงที่ไว้ในพรอมป์ คุณก็ต้องเสียโทเค็นสำหรับเนื้อหานั้นไปตลอด
# Classify each behavior element before deciding where it lives
def placement(element):
# element: dict with 'changes_per_call' and 'repeated_every_call'
if element['changes_per_call']:
return 'PROMPT' # volatile -> must stay dynamic
if element['repeated_every_call']:
return 'WEIGHTS' # stable + repetitive -> distill into tuning
return 'PROMPT' # default to the flexible layer
print(placement({'changes_per_call': False, 'repeated_every_call': True}))
# WEIGHTSรูปแบบ A: การกลั่นพรอมป์
นี่คือรูปแบบไฮบริดที่มีคุณค่ามากที่สุด คุณพัฒนาพรอมป์ที่ยาวและมีคุณภาพสูง ใช้พรอมป์นั้นสร้างคำตอบมาตรฐาน จากนั้น ปรับแต่งโมเดลด้วยคำตอบเหล่านั้นโดยใช้พรอมป์สั้น
ผลลัพธ์คือโมเดลจะทำงานเสมือนว่ายังมีพรอมป์ยาวอยู่ แต่คุณใช้โทเค็นเพียงเศษเสี้ยว พรอมป์ราคาแพงกลายเป็นครู ส่วนพรอมป์ราคาถูกกลายเป็นอินเทอร์เฟซขณะทำงาน ทั้งเวลาแฝง ต้นทุน และความสม่ำเสมอดีขึ้นพร้อมกัน
# Build distillation set: long prompt -> output, store with SHORT prompt
def distill_example(input_x, long_prompt, teacher):
full = long_prompt + '\n\n' + input_x
gold = teacher(full) # quality from the long prompt
short = 'Task: process the input.\n' + input_x # runtime prompt
return {'messages': [
{'role': 'user', 'content': short},
{'role': 'assistant', 'content': gold},
]}รูปแบบ B: ปรับแต่งรูปแบบ ใช้พรอมป์กับเนื้อหา
ปรับแต่งโมเดลให้ ส่งออกโครงสร้างที่ถูกต้องเสมอ ไม่ว่าจะเป็นสคีมาที่เคร่งครัด น้ำเสียงประจำองค์กร หรือ DSL เฉพาะโดเมน แล้วให้พรอมป์รับหน้าที่ส่งเนื้อหาสำหรับคำขอแต่ละรายการ
รูปแบบนี้เหมาะอย่างยิ่งเมื่อจำเป็นต้องปฏิบัติตามรูปแบบให้เกือบสมบูรณ์แบบ และมีกฎมากเกินกว่าจะระบุได้ครบถ้วน แต่เนื้อหาจริงเปลี่ยนแปลงอยู่เสมอ โมเดลที่ปรับแต่งแล้วจะไม่ต่อต้านคุณในเรื่องโครงสร้าง ทำให้เหลือโทเค็นพรอมป์สำหรับคำสั่งและบริบทที่ดึงมาได้มากขึ้น
รูปแบบ C: เราเตอร์ที่ปรับแต่งแล้วกับผู้เชี่ยวชาญที่รับพรอมป์
ในระบบที่มีหลายขั้นตอน ให้ปรับแต่งโมเดลขนาดเล็กที่ทำงานเร็วสำหรับ การตัดสินใจที่แคบและมีปริมาณสูง เช่น การจำแนก การจัดเส้นทาง และการดึงข้อมูล แล้วเก็บโมเดลขนาดใหญ่ที่รับพรอมป์ไว้สำหรับขั้นตอนการให้เหตุผลแบบปลายเปิด
คุณจะได้ต้นทุนและเวลาแฝงของโมเดลขนาดเล็กที่ปรับแต่งแล้วเมื่อภารกิจมีขอบเขตแคบ พร้อมความยืดหยุ่นของการใช้พรอมป์เมื่อภารกิจมีขอบเขตกว้าง เราเตอร์มีพฤติกรรมคงที่และผ่านการปรับแต่งแล้ว ส่วนผู้เชี่ยวชาญยังรับพรอมป์ได้เมื่อข้อกำหนดเปลี่ยนแปลงไป
def pipeline(user_input, router_tuned, expert_prompted):
route = router_tuned(user_input) # cheap, fast, learned
if route == 'simple':
return router_tuned(user_input) # small model handles it
# complex -> hand to large prompted model with full instructions
return expert_prompted(
'Detailed instructions...\n' + user_input
)เก็บ RAG ไว้ในชั้นพรอมป์
แม้จะใช้โมเดลที่ปรับแต่งแล้ว ความรู้ก็ควรได้มาจากการดึงข้อมูล ไม่ใช่การฝึก โมเดลไฮบริดเรียนรู้ วิธีใช้บริบท ส่วนพรอมป์จะระบุว่าในคำขอนี้ต้องใช้บริบท ใด
นี่คือเหตุผลที่ระบบไฮบริดมีอายุการใช้งานที่ดี พฤติกรรมพื้นฐานถูกตรึงไว้ในน้ำหนัก แต่ข้อเท็จจริงจะได้รับการปรับปรุงทุกครั้งที่เรียกใช้ผ่านการดึงข้อมูล คุณปรับแต่งใหม่ไม่บ่อยนักเพื่อปรับพฤติกรรม ขณะเดียวกันก็อัปเดตความรู้ได้อย่างต่อเนื่องโดยไม่มีต้นทุนการฝึก
การปรับแต่งแบบเบา: LoRA และอะแดปเตอร์
ระบบไฮบริดเหมาะกับการปรับแต่งแบบ เบา อะแดปเตอร์รูปแบบ LoRA จะฝึกพารามิเตอร์เพิ่มเติมเพียงชุดเล็ก โดยปล่อยให้โมเดลพื้นฐานคงเดิม อะแดปเตอร์เหล่านี้มีราคาถูก ปรับปรุงซ้ำได้รวดเร็ว และนำมาซ้อนกันได้
- ฝึกอะแดปเตอร์หลายตัวสำหรับงานต่างกันบนโมเดลพื้นฐานเดียวกัน
- สลับอะแดปเตอร์ขณะให้บริการได้โดยไม่ต้องโหลดโมเดลพื้นฐานใหม่
- ฝึกอะแดปเตอร์ใหม่ภายในไม่กี่ชั่วโมงแทนที่จะเป็นหลายวันเมื่อพฤติกรรมเริ่มเปลี่ยนไป
วิธีนี้ทำให้ระบบไฮบริดยังคงมีความเร็วในการปรับปรุงใกล้เคียงกับการใช้พรอมป์ พร้อมได้ประโยชน์ด้านความสม่ำเสมอจากการปรับแต่ง
หลีกเลี่ยงการระบุซ้ำซ้อน
ข้อผิดพลาดคลาสสิกของระบบไฮบริดคือ โมเดลถูกปรับแต่งให้ทำ X และพรอมป์ก็ยังสั่งให้ทำ X อยู่ โทเค็นพรอมป์ที่ซ้ำซ้อนทำลายจุดประสงค์ของการกลั่น และอาจขัดแย้งกับพฤติกรรมที่โมเดลเรียนรู้มาได้
หลังการปรับแต่ง ให้ ตัดสิ่งที่ซ้ำซ้อนออกจากพรอมป์อย่างจริงจัง โดยลบทุกอย่างที่ถูกฝังไว้ในน้ำหนักแล้ว จากนั้นเรียกใช้การประเมินอีกครั้งหลังตัดออก เพื่อยืนยันว่าพฤติกรรมที่ปรับแต่งแล้วยังคงอยู่โดยไม่ต้องมีคำสั่งซ้ำซ้อน
# After tuning, prune prompt lines that the model now does on its own
def trim_prompt(prompt_lines, behaviors_in_weights):
return [ln for ln in prompt_lines
if not any(b in ln for b in behaviors_in_weights)]
kept = trim_prompt(
['Use JSON schema', 'Write in formal tone', 'Answer the question'],
behaviors_in_weights=['JSON schema', 'formal tone'])
print(kept) # ['Answer the question'] -- only the volatile part remainsจัดการเวอร์ชันของสองชั้นร่วมกัน
ระบบไฮบริดมีสิ่งประดิษฐ์สองอย่างที่เชื่อมโยงกัน ได้แก่ เวอร์ชันของอะแดปเตอร์ และ เวอร์ชันของแม่แบบพรอมป์ ทั้งสองต้องจัดการเวอร์ชันและนำไปใช้งานเป็นคู่ พรอมป์ที่เขียนสำหรับอะแดปเตอร์ v3 อาจทำงานผิดพลาดบนอะแดปเตอร์ v4
กำหนดคู่เวอร์ชันไว้ในการตั้งค่า เรียกใช้การประเมินกับคู่ที่ตรงกับสิ่งที่จะนำไปใช้งานทุกประการ และย้อนกลับทั้งคู่พร้อมกัน การปฏิบัติต่อทั้งสองอย่างแยกจากกันเป็นสาเหตุที่พบบ่อยที่สุดของการถดถอยแบบเงียบในระบบไฮบริด
ความถี่ในการปรับแต่งใหม่
เนื่องจากพฤติกรรมที่ผันผวนอยู่ในพรอมป์ ระบบไฮบริดที่สร้างมาอย่างดีจึงต้องปรับแต่งใหม่ ไม่บ่อย โดยหลักแล้วทำเมื่อโมเดลพื้นฐานเลิกใช้งานแล้ว หรือเมื่อพฤติกรรมคงที่เปลี่ยนไปอย่างแท้จริง การเปลี่ยนแปลงในแต่ละวันเกิดขึ้นที่ชั้นพรอมป์โดยไม่มีต้นทุนการฝึก
หากพบว่าตนเองต้องปรับแต่งใหม่บ่อยครั้ง นั่นแสดงว่าคุณแยกส่วนคงที่/ผันผวนไม่ถูกต้อง เนื้อหาที่ผันผวนรั่วไหลเข้าไปอยู่ในน้ำหนักแล้ว ย้ายเนื้อหานั้นกลับไปไว้ในพรอมป์
โครงร่างระบบไฮบริดตั้งแต่ต้นจนจบ
วงจรทั้งหมดมีดังนี้ ดึงบริบทมา สร้างพรอมป์สั้นโดยอิงกับอะแดปเตอร์ที่ปรับแต่งแล้ว และให้น้ำหนักจัดหาโครงสร้างที่เรียนรู้มา ความรู้และคำสั่งยังคงเปลี่ยนแปลงได้ ส่วนโครงสร้างและน้ำเสียงถูกฝังไว้แล้ว
def hybrid_call(user_q, retriever, tuned_model, adapter_version):
docs = retriever.search(user_q, k=4) # volatile knowledge
ctx = '\n'.join(d.text for d in docs)
short_prompt = (
'Answer from context.\n' # form is in weights
'<context>' + ctx + '</context>\n'
'<q>' + user_q + '</q>'
)
return tuned_model.generate(short_prompt, adapter=adapter_version)ตรวจสอบอย่างรวดเร็ว
คุณกลั่นพรอมป์ยาวให้เป็นอะแดปเตอร์ LoRA เพื่อให้โมเดลส่งออกสคีมา JSON ที่เคร่งครัดและน้ำเสียงประจำองค์กรของคุณเสมอ พรอมป์ขณะทำงานควรเปลี่ยนแปลงอย่างไร
สรุปทบทวน
ไฮบริด = ปรับแต่งสำหรับพฤติกรรมคงที่ ใช้พรอมป์สำหรับบริบทที่ผันผวน แยกพฤติกรรมตามแกนคงที่/ผันผวน แล้วให้แต่ละชั้นทำสิ่งที่ตนถนัดที่สุด
- การกลั่นพรอมป์: พรอมป์ยาวทำหน้าที่สอน พรอมป์สั้นทำหน้าที่ให้บริการ
- ปรับแต่งรูปแบบ ใช้พรอมป์กับเนื้อหา ใช้เราเตอร์ที่ปรับแต่งแล้วร่วมกับผู้เชี่ยวชาญที่รับพรอมป์
- เก็บความรู้ไว้ในการดึงข้อมูล เพื่อให้ระบบไฮบริดมีอายุการใช้งานที่ดี
- เลือกใช้อะแดปเตอร์รูปแบบ LoRA แบบเบาเพื่อให้ปรับปรุงซ้ำได้รวดเร็ว
- ตัดคำสั่งที่ระบุซ้ำซ้อน และจัดการเวอร์ชันของอะแดปเตอร์กับพรอมป์เป็นคู่
- การปรับแต่งใหม่บ่อยครั้งหมายความว่าเนื้อหาที่ผันผวนรั่วไหลเข้าไปในน้ำหนัก ให้ย้ายกลับไปไว้ในพรอมป์
คำถามที่พบบ่อย
บทเรียน “แบบผสม: พรอมต์และการปรับแต่งเล็กน้อย” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “แบบผสม: พรอมต์และการปรับแต่งเล็กน้อย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “แบบผสม: พรอมต์และการปรับแต่งเล็กน้อย” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม
ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- เมื่อการใช้พรอมต์ก็เพียงพอ
- เมื่อใดควรปรับแต่งละเอียด
- แบบผสม: พรอมต์และการปรับแต่งเล็กน้อย
- การประเมินการตัดสินใจ