Core prompt engineering techniques — เทคนิคพื้นฐานของ Prompt Engineering

Prompt Engineering ครอบคลุมเทคนิคและวิธีการที่หลากหลาย ซึ่งมุ่งเน้นการปรับปรุงการโต้ตอบกับโมเดลภาษาขนาดใหญ่ (LLM) เพื่อให้ได้ผลลัพธ์ที่ต้องการ เทคนิคเหล่านี้เกี่ยวข้องกับการจัดโครงสร้างคำถาม การให้บริบท การควบคุมรูปแบบของผลลัพธ์ และการเพิ่มความสามารถในการให้เหตุผลของโมเดล เนื่องจาก LLM สร้างคำตอบโดยการทำนาย token ถัดไปจาก prompt ที่ป้อนเข้าไป คุณภาพและโครงสร้างของ prompt จึงส่งผลโดยตรงต่อผลลัพธ์ที่ได้ เทคนิคพื้นฐานของ Prompt Engineering ช่วยให้นักพัฒนาและผู้ใช้สามารถควบคุมพฤติกรรมของโมเดลได้อย่างมีประสิทธิภาพ ลดข้อผิดพลาด และปรับโมเดลให้เหมาะกับงานเฉพาะด้าน โดยไม่จำเป็นต้องเปลี่ยนแปลงพารามิเตอร์ภายในของโมเดล

หลักการพื้นฐานและโครงสร้างของ Prompt

แม้ว่าการนำไปใช้งานจริงจะแตกต่างกันออกไป แต่ prompt ที่มีประสิทธิภาพมักถูกสร้างขึ้นโดยคำนึงถึงหลักการและโครงสร้างทั่วไป:

• แนวทางเชิงประจักษ์: โครงสร้างหนึ่งที่แนะนำในทางปฏิบัติ (แต่ไม่ใช่มาตรฐานอุตสาหกรรม) คือการยึดหลักการดังต่อไปนี้ ได้แก่ กำหนดทิศทาง ระบุรูปแบบ ให้ตัวอย่าง ประเมินคุณภาพ และแบ่งงานออกเป็นส่วนย่อย
• prompt ที่มีประสิทธิภาพมักประกอบด้วยองค์ประกอบต่อไปนี้:
  • บทนำ/บทบาท: กำหนดบริบทของงานหรือบทบาท/ตัวละครของโมเดล
  • คำสั่ง: การชี้แนะที่ชัดเจนว่าต้องทำอะไร
  • บริบท: ข้อมูลที่จำเป็น (แบบคงที่หรือดึงมาแบบไดนามิกผ่าน RAG)
  • ตัวอย่าง (Few-shot): การแสดงรูปแบบ/สไตล์ที่ต้องการ
  • คำขอคำตอบ: การระบุอย่างชัดเจนว่าโมเดลต้องสร้างอะไร

• System Prompt: ในอินเทอร์เฟซแบบแชทผ่าน API (เช่น โมเดลของ OpenAI, Anthropic) ช่วยให้สามารถกำหนดคำสั่งทั่วไปและบทบาทสำหรับทั้ง session ได้
• การจัดรูปแบบ: การใช้ Markdown, JSON, XML หรือ YAML ช่วยจัดโครงสร้าง prompt และทำให้การแยกวิเคราะห์คำตอบทำได้ง่ายขึ้น ตัวคั่น (```, `"""`, XML tags) มีความสำคัญในการแยกคำสั่งออกจากข้อมูล

เทคนิคหลักด้านคำสั่งและตัวอย่าง

• คำสั่งที่ชัดเจนและเฉพาะเจาะจง: อธิบายงาน ผลลัพธ์ที่ต้องการ และข้อจำกัดให้ละเอียดที่สุด หลีกเลี่ยงความกำกวม
• Role Prompting: การกำหนดบทบาทให้กับโมเดล (เช่น "คุณคือผู้เชี่ยวชาญด้าน...") เพื่อควบคุมน้ำเสียง สไตล์ และฐานความรู้
• Zero-shot Prompting: การส่งคำถามโดยไม่มีตัวอย่าง มีประสิทธิภาพสำหรับงานง่ายๆ หรืองานที่โมเดลคุ้นเคยดี
• Few-Shot Prompting: การให้ตัวอย่างคู่ "คำถาม-คำตอบ" จำนวนหนึ่ง (โดยทั่วไป 2 ถึง 5 ตัวอย่าง) เพื่อแสดงให้เห็นลักษณะของงาน กรณีพิเศษคือ One-shot Prompting ที่ให้ตัวอย่างเพียงตัวอย่างเดียว มีประโยชน์อย่างยิ่งสำหรับรูปแบบหรือสไตล์ที่ซับซ้อน ต้องใช้อย่างระมัดระวังเพื่อหลีกเลี่ยงการยึดติด (anchoring) หรือการจับรูปแบบผิดๆ จากตัวอย่าง

เทคนิคการจัดการบริบท

• Retrieval-Augmented Generation (RAG): การเพิ่มข้อมูลที่เกี่ยวข้องจากฐานความรู้ภายนอกลงใน prompt แบบไดนามิกก่อนส่งให้ LLM วิธีนี้ถูกเสนอครั้งแรกโดย Meta AI ในปี 2020 และเป็นวิธีสำคัญในการต่อสู้กับ hallucination และรับรองความทันสมัยของข้อมูล
• Chunking: การแบ่งข้อความขนาดใหญ่ออกเป็นส่วนย่อย (chunk) เพื่อให้พอดีกับ context window ของโมเดล กลยุทธ์ต่างๆ ได้แก่ การแบ่งตามประโยค ย่อหน้า หรือ token (แบบมีการทับซ้อน)
• การสรุปความ: การบีบอัดข้อความยาวหรือประวัติการสนทนาเพื่อถ่ายทอดความหมายหลักในบริบทที่จำกัด

เทคนิคการปรับปรุงการให้เหตุผล (Reasoning)

เทคนิคเหล่านี้มุ่งเน้นให้โมเดล "คิด" อย่างรอบคอบและมีโครงสร้างมากขึ้น ประสิทธิภาพของหลายเทคนิค โดยเฉพาะ CoT จะแสดงให้เห็นชัดในโมเดลขนาดใหญ่ (โดยทั่วไปมากกว่า 100 พันล้านพารามิเตอร์)

• Chain-of-Thought (CoT): การสั่งให้โมเดลสร้างการให้เหตุผลทีละขั้นตอนก่อนให้คำตอบสุดท้าย ช่วยปรับปรุงผลลัพธ์อย่างมีนัยสำคัญในด้านคณิตศาสตร์ ตรรกะ และงานหลายขั้นตอน
  • Zero-shot CoT: รูปแบบที่ง่ายที่สุด ไม่ต้องการตัวอย่าง การเพิ่มวลีเช่น «ลองคิดทีละขั้นตอน» (Let's think step by step) ลงใน prompt ก็สามารถกระตุ้นลูกโซ่การให้เหตุผลได้
• รูปแบบต่างๆ ของ CoT:
  • Auto-CoT: การสร้างตัวอย่างการให้เหตุผลอัตโนมัติสำหรับ few-shot prompting
  • Self-Consistency: การสร้างลูกโซ่การให้เหตุผลหลายชุดและเลือกคำตอบที่พบบ่อยที่สุดโดยการ "โหวต" ซึ่งช่วยเพิ่มความน่าเชื่อถือ
  • Tree-of-Thoughts (ToT): การสำรวจเส้นทางการให้เหตุผลหลายเส้นทางในรูปแบบต้นไม้ โดยสามารถย้อนกลับและประเมินขั้นตอนระหว่างกลางได้ เทคนิคนี้แสดงประสิทธิภาพสูงในงานที่ซับซ้อน เช่น ช่วยเพิ่มอัตราความสำเร็จในการแก้ "Game of 24" จากประมาณ 4% เป็นประมาณ 74%
  • Graph-of-Thought (GoT), LogiCoT และอื่นๆ ที่มุ่งเน้นการให้เหตุผลที่ซับซ้อนหรือตรวจสอบได้ทางตรรกะ
• ReAct (Reason and Act): เทคนิคที่พัฒนาต่อยอดจาก CoT เป็นวงจรแบบวนซ้ำที่โมเดลสลับระหว่างขั้นตอนการให้เหตุผล (Thought) และการกระทำโดยใช้เครื่องมือ (Act) โดยอัปเดตความเข้าใจตามผลการสังเกต (Observation)
• Self-Refine: กระบวนการวนซ้ำที่โมเดลสร้างคำตอบก่อน จากนั้นวิจารณ์คำตอบนั้น และสุดท้ายปรับปรุงตามการวิจารณ์ของตัวเอง วงจร "สร้าง-วิจารณ์-ปรับปรุง" นี้สามารถทำซ้ำได้หลายครั้ง
• Take a Step Back Prompting: โมเดลจะกำหนดหลักการทั่วไปหรือสิ่งที่เป็นนามธรรมก่อน จากนั้นจึงนำไปประยุกต์ใช้กับงานเฉพาะ

เทคนิคขั้นสูง: ตัวแทนและเครื่องมือ

• Tool Usage / Function Calling: การให้ LLM สามารถเรียกใช้ API ภายนอกได้ (การค้นหา เครื่องคิดเลข ฐานข้อมูล) โมเดลจะสร้างคำขอที่มีโครงสร้างสำหรับการเรียกใช้เครื่องมือ ซึ่งแอปพลิเคชันจะดำเนินการและส่งผลลัพธ์กลับมายังโมเดล LLM ยุคใหม่ (GPT-4, Claude 3) มีการสนับสนุนฟังก์ชันนี้ในตัว
• Agents: ระบบที่ใช้ LLM เป็นฐาน ซึ่งสามารถวางแผน ใช้เครื่องมือ และดำเนินการเพื่อบรรลุเป้าหมายได้อย่างอิสระ มักใช้วงจรคล้าย ReAct framework ต่างๆ (LangChain, AutoGen, CrewAI) ช่วยให้การสร้างระบบเหล่านี้ทำได้ง่ายขึ้น
• ระบบหลายตัวแทน (Multi-agent Systems): การโต้ตอบระหว่าง agent ที่เชี่ยวชาญหลายตัวเพื่อแก้ปัญหาที่ซับซ้อน

เทคนิคการลดข้อผิดพลาดและ Hallucination

• RAG: การผูกคำตอบกับข้อมูลเชิงข้อเท็จจริงที่ดึงมาได้
• คำสั่งจำกัดขอบเขตคำตอบ: การกำหนดให้ตอบเฉพาะจากบริบทที่ให้ไว้เท่านั้น หรือให้ระบุความไม่แน่ใจ (เช่น "หากไม่ทราบคำตอบ ให้บอกว่า 'ไม่ทราบ'")
• การขอการอ้างอิง: การกำหนดให้โมเดลระบุแหล่งที่มาหรืออ้างอิงส่วนของบริบทที่คำตอบอ้างอิงถึง
• การตรวจสอบและการวิจารณ์ตัวเอง: การใช้เทคนิคเช่น Chain-of-Verification (CoVe) (การสร้างคำตอบแล้วตรวจสอบและแก้ไขในภายหลัง), Self-Refine หรือการขอให้โมเดลตรวจสอบคำตอบของตัวเองเพื่อหาข้อผิดพลาดโดยตรง
• CoT: การให้เหตุผลทีละขั้นตอนโดยตัวมันเองสามารถลดข้อผิดพลาดเชิงตรรกะได้

เทคนิคการประเมินและการวนซ้ำ

แม้ว่าการประเมินจะเป็นกระบวนการแยกต่างหาก แต่บางแง่มุมของมันเป็นส่วนหนึ่งของ Prompt Engineering:

• A/B Testing ของ Prompt: การเปรียบเทียบประสิทธิภาพของ prompt เวอร์ชันต่างๆ กับงานเดียวกัน
• การใช้ LLM เพื่อการประเมิน: การใช้โมเดลที่มีประสิทธิภาพสูง (เช่น GPT-4) เพื่อประเมินคุณภาพของคำตอบที่สร้างโดย prompt หรือโมเดลอื่น (LLM-as-a-Judge)

Pattern ของ Prompt

โครงสร้างที่ใช้ซ้ำได้ทั่วไป:

• Persona Pattern
• Output Customization Pattern
• Question Refinement Pattern
• Cognitive Verifier / Self-Critique Pattern
• Step-by-Step / Chain-of-Thought Pattern
• Template Pattern

เอกสารอ้างอิง

• Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. PDF.
• Brown, T. B. et al. (2020). Language Models are Few-Shot Learners. arXiv:2005.14165.
• Lewis, P. et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. arXiv:2005.11401.
• Li, X. L.; Liang, P. (2021). Prefix-Tuning: Optimizing Continuous Prompts for Generation. arXiv:2101.00190.
• Liu, Y. et al. (2021). Fantastically Ordered Prompts and Where to Find Them: Overcoming Few-Shot Prompt Order Sensitivity. arXiv:2104.08786.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.
• Wei, J. et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903.
• Wang, X. et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171.
• Kojima, T. et al. (2022). Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916.
• Zhang, Z. et al. (2022). Automatic Chain of Thought Prompting in Large Language Models. arXiv:2210.03493.
• Zhou, D. et al. (2022). Least-to-Most Prompting Enables Complex Reasoning in Large Language Models. arXiv:2205.10625.
• Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
• Besta, M. et al. (2023). Graph of Thoughts: Solving Elaborate Problems with Large Language Models. arXiv:2308.09687.
• Madaan, A. et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. arXiv:2303.17651.
• Schick, T. et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. arXiv:2302.04761.
• Rafailov, R. et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. arXiv:2305.18290.
• Wang, Y. et al. (2023). Self-Instruct: Aligning Language Models with Self-Generated Instructions. arXiv:2212.10560.
• Yao, S. et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601.
• Chen, S. Y. et al. (2023). Extending Context Window of Large Language Models via Positional Interpolation. arXiv:2306.15595.
• Chang, K. et al. (2024). Efficient Prompting Methods for Large Language Models: A Survey. arXiv:2404.01077.
• Genkina, D. (2024). AI Prompt Engineering Is Dead. IEEE Spectrum. [1].
• Li, Z. et al. (2024). Prompt Compression for Large Language Models: A Survey. arXiv:2410.12388.
• Liang, X. et al. (2024). Internal Consistency and Self-Feedback in Large Language Models: A Survey. arXiv:2407.14507.
• Han, H. et al. (2025). Retrieval-Augmented Generation with Graphs (GraphRAG). arXiv:2501.00309.
• Li, W. et al. (2025). A Survey of Automatic Prompt Engineering: An Optimization Perspective. arXiv:2502.11560.
• Wu, Z. et al. (2025). The Dark Side of Function Calling: Pathways to Jailbreaking Large Language Models. EMNLP 2025. PDF.
• Yang, B. et al. (2025). Hallucination Detection in Large Language Models with Metamorphic Relations. arXiv:2502.15844.

ดูเพิ่มเติม

• โมเดลภาษาขนาดใหญ่
• Chain-of-Thought Prompting
• Hallucination และคำตอบที่ไม่ถูกต้องของ LLM