องค์ที่ 1 · ตอนที่ 02

คู่หูด่านแรก: Prompt และ สมองกล (Brain)

คู่หูด่านแรก: Prompt และ สมองกล (Brain)

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

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

นั่นคือช่วงเวลาที่เกิดคู่หูพื้นฐาน:

แผนภาพประกอบ chapter 02 diagram 01
แผนภาพประกอบเรื่อง

ในวงจรนี้ มีตัวละครหลักอยู่เพียง 2 ตัวเท่านั้นครับ:

  1. Prompt (ข้อมูลนำเข้าที่ระบบจัดเตรียมให้โมเดลในรอบนั้น)
  2. Model หรือ Brain (สมองกลที่รับข้อมูลไปสร้างคำตอบ)

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

วันที่คุยกับน้องในทีม... ด้วยความไม่รู้

เรื่องนี้เกิดขึ้นเมื่อไม่นานมานี้เองครับ ราว ๆ ปลายปี 25

ถ้าพูดกันตามตรงแบบไม่อายเลยนะครับ ตอนนั้นตัวผมเองแทบไม่รู้เรื่องอะไรเกี่ยวกับ AI เลยครับ! 55555

แม้ว่าผมจะทำงานเป็น Software Architect พัฒนาระบบซอฟต์แวร์ ออกแบบฐานข้อมูล และเขียนโปรแกรมมานานหลายสิบปี แต่สำหรับเรื่อง "AI" ในวันนั้น มันเหมือนเป็นโลกใบใหม่ที่ผมยังไม่เคยลงไปแตะ จนกระทั่งมีโปรเจกต์งานหนึ่งเข้ามา และผมเห็นน้องโปรแกรมเมอร์ในทีมกำลังเตรียมลุยงานระบบ AI อยู่คนเดียว

ตอนที่นั่งคุยกันในทีม น้องเขาก็เล่าแผนงานให้ฟังด้วยความกระตือรือร้น ว่าจะใช้โมเดลภาษาขนาดใหญ่ (LLM) ตัวนั้นตัวนี้

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

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

แต่พอผมก้มลงไปไล่ดูโค้ดจริง ๆ บรรทัดที่โปรแกรมยื่นมือไปคุยกับสมองกล... ผมกลับต้องยืนอึ้งด้วยความแปลกใจอย่างแรง!

เพราะในโค้ดนั้น ไม่มีอะไรที่ใกล้เคียงกับภาพความฉลาดล้ำที่ผมจินตนาการไว้เลยครับ สิ่งที่น้องเขียนไว้ มีเพียงแค่:

  1. การเขียนโค้ดเพื่อรวบรวมข้อมูลต่าง ๆ มาประกอบร่างเป็นชุดข้อมูล เรียกว่า Prompt
  2. แล้วยิงคำสั่งส่ง Prompt นั้นไปหาตัว Model
  3. แล้วก็มีคำสั่งสั้น ๆ บอกมันว่า: "เอาข้อมูลนี้ไป แล้วสร้างคำตอบกลับมานะ" (คำสั่งพวกตระกูล Completion นั่นแหละครับ)

เสร็จแล้วครับ! โค้ดที่คุยกับสมองกลระดับโลก มีใจความสำคัญอยู่แค่นั้นจริง ๆ!

ผมยืนเกาหัวด้วยความสงสัยทันทีว่า: “อ้าว... มีแค่นี้เองเหรอวะ? แค่เตรียมข้อมูลก้อนหนึ่ง ยิงไปบอกสมองกลให้สร้างคำตอบกลับมา... แค่นี้จริง ๆ แล้วมันจะกลายเป็นระบบที่คุยฉอด ๆ บนหน้าจอได้ยังไง?”

และนั่นคือจุดเริ่มต้นที่ทำให้ผมต้องมาทำความเข้าใจคู่หู 2 ตัวนี้ใหม่อย่างจริงจังครับ

ตัวละครที่ 1: "Prompt" คืออะไร?

เวลาเราเปิดหน้าต่างแชตขึ้นมา แล้วพิมพ์ประโยคคำถามลงไป พวกเรามักจะเรียกข้อความนั้นติดปากว่า Prompt (หรือถ้าเรียกให้เจาะจงลงไปอีกนิด ก็คือ User Prompt / User Message)

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

แต่ในระบบจริง ๆ ที่เราคุยโต้ตอบกันเป็นเรื่องเป็นราว... ภาพมันกว้างและลึกกว่านั้นครับ!

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

  • เราพิมพ์ข้อความใหม่เข้าไปประโยคเดียว (User Message)
  • ระบบหลังบ้านหยิบข้อความนั้น ไปร้อยต่อกับประวัติที่เราเพิ่งคุยค้างไว้ (Conversation)
  • แล้วแอบเอาไปประกบรวมกับกฎเกณฑ์ บทบาท ข้อห้าม และข้อมูลแวดล้อมต่าง ๆ

ของทั้งหมดนี้ พอรวมกันจนกลายเป็น "ข้อมูลนำเข้าที่ระบบจัดเตรียมให้โมเดลในรอบนั้น"... สิ่งนี้แหละครับ คือสิ่งที่คนทำระบบเรียกว่า Prompt!

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

แล้ว "Prompt ที่ดี" หน้าตาเป็นอย่างไร?

ในเมื่อ Prompt คือข้อมูลนำเข้าที่ระบบจัดเตรียมให้โมเดลอ่าน Prompt ที่ดีที่จะช่วยให้โมเดลเข้าใจโจทย์และตอบตรงเป้าหมายขึ้น จึงมีหลักการสำคัญอยู่ 3 ข้อครับ:

  1. ชัดเจนและตรงประเด็น (Clear & Direct): มีเป้าหมายที่แน่นอน บอกชัดเจนว่าต้องการผลลัพธ์อะไร ไม่คลุมเครือ
  2. มีบริบทและข้อมูลแวดล้อมที่จำเป็น (Relevant Context): มีข้อมูลประกอบที่เพียงพอต่อการตอบ เช่น เงื่อนไขเฉพาะ กฎเกณฑ์ หรือข้อจำกัด
  3. จัดโครงสร้างให้อ่านง่าย (Well-Structured): มีการแยกแยะชัดเจนว่า ท่อนไหนคือกฎ ท่อนไหนคือข้อมูลอ้างอิง และท่อนไหนคือคำถาม เพื่อให้สมองกลไม่งง

และนี่แหละครับ คือความลับที่ผมอยากแอบบอกทุกคนไว้ตรงนี้เลย:

ในเมื่อคนทำระบบอย่างผม รู้ดีว่า Prompt คือการประกอบร่างของข้อมูลทั้งหมด...
เวลาที่ผมใช้งานหน้าจอแชต ผมจึงแทบไม่ค่อยได้มานั่งพิมพ์ข้อความยาว ๆ เฟื้อย ๆ เพื่อสั่งงานเลยครับ! 55555

ทำไมถึงเป็นแบบนั้น? ก็เพราะผมปล่อยให้ "ระบบหลังบ้าน" มันทำหน้าที่ประกอบร่างส่วนที่ยาวและซับซ้อนให้เอง ส่วนตัวผมมีหน้าที่แค่พิมพ์ Message สั้น ๆ ที่ตรงประเด็นเข้าไปเท่านั้น!

ส่วนเทคนิคว่าเราจะสร้างระบบให้ช่วยประกอบ Prompt ยาว ๆ ให้เราได้อย่างไร โดยที่เราไม่ต้องเหนื่อยพิมพ์เอง... เดี๋ยวผมจะได้เล่าให้ฟังอย่างละเอียดในบทต่อ ๆ ไปแน่นอนครับ!

ตัวละครที่ 2: "Model (Brain)" — มองมันเป็นแค่กล่องดำ

พอส่ง Prompt เข้าไปแล้ว อีกฝั่งหนึ่งที่นั่งรอรับอยู่ ก็คือ Model หรือที่พวกเราเรียกกันติดปากว่า สมองกล (Brain) นั่นเองครับ

ในบทนี้ ผมอยากชวนทุกคนมองเจ้าสมองกลนี้ในฐานะ "กล่องดำ" (Black Box) ใบหนึ่งก็พอครับ:

แผนภาพประกอบ chapter 02 diagram 02
แผนภาพประกอบเรื่อง

เราไม่ต้องไปสนใจว่าข้างในกล่องดำใบนี้มีสายไฟกี่เส้น มีสูตรคณิตศาสตร์กี่พันสูตร หรือคำนวณตัวเลขอย่างไร (ไม่อย่างนั้นพวกเราม้วนเสื่อกลับบ้านกันหมดแน่ครับ 55555)

หน้าที่ของมันตามสัญญาการทำงาน (Contract) มีอยู่อย่างเดียวจริง ๆ ครับ: “รับ Prompt ก้อนนั้นเข้าไป แล้วก้มหน้าก้มตา 'สร้างคำตอบ' หรือสร้างผลลัพธ์กลับคืนมาให้เรา!”

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

สรุปภาพรวม: ความเรียบง่ายที่อยู่หลังม่าน

เห็นไหมครับว่า พอเราเข้าใจเส้นแบ่งของคำศัพท์เหล่านี้อย่างถูกต้อง:

  • สิ่งที่เราพิมพ์ คือ Message
  • สายธารเรื่องราวที่เราคุยโต้ตอบกัน คือ Conversation
  • และข้อมูลที่ระบบเตรียมให้โมเดลในรอบนั้น คือ Prompt

ภาพที่เคยดูซับซ้อนก็กลายเป็นเรื่องเข้าใจง่ายทันที!

ตัว Model (Brain) จึงไม่ต้องไปจำอดีต ไม่ต้องมานั่งคิดว่ากำลังคุยกับใคร หน้าที่ของมันเปรียบเหมือนกล่องดำที่ซื่อสัตย์: เมื่อได้รับ Prompt ก้อนนั้นเข้าไป มันก็แค่ก้มหน้าก้มตา "สร้างคำตอบ" กลับคืนมาให้เรา เท่านั้นเองครับ!

ก้าวต่อไป: คอมพิวเตอร์อ่านภาษาคนได้อย่างไร?

มาถึงตรงนี้ เราเห็นภาพคู่หูคู่นี้ชัดเจนแล้วใช่ไหมครับ:

  • เราเตรียมโจทย์ (Prompt)
  • ยื่นให้กล่องดำ (Model)
  • แล้วกล่องดำก็มีหน้าที่ ไปสร้างคำตอบ กลับมา

แต่เคยสงสัยไหมครับว่า... ในเมื่อคอมพิวเตอร์เป็นแค่แผงวงจรอิเล็กทรอนิกส์ มีแต่กระแสไฟฟ้าและตัวเลข 0 กับ 1...

แล้วเจ้ากล่องดำใบนี้ มัน "อ่าน" ตัวหนังสือภาษาไทย หรือภาษาอังกฤษที่เราป้อนเข้าไปได้อย่างไร?
มันมองเห็นตัวหนังสือเป็นคำ ๆ เหมือนที่ตามนุษย์เรามองเห็นจริงหรือ?

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

คำที่เรียกว่า "Token" ครับ!

ศัพท์เทคนิค → คำแปลภาษาคนทำงาน — แตะเพื่อย่อ/ขยาย
  • Message (ข้อความ): ข้อความที่ผู้ใช้พิมพ์ป้อนเข้ามาในแต่ละครั้ง (ในการใช้งานแบบง่ายที่สุด ข้อความนี้ก็อาจทำหน้าที่เป็น Prompt ทั้งหมดได้เลย แต่ในระบบจริง มันมักจะเป็นชิ้นส่วนหนึ่งที่ถูกนำไปประกอบร่างต่อ)
  • Conversation (บทสนทนา): สายธารประวัติการคุยโต้ตอบ (คำถามเดิม + คำตอบเดิม) ที่นำมาร้อยเรียงต่อกัน
  • Prompt (ข้อมูลที่ระบบเตรียมให้โมเดลในรอบนั้น): ก้อนข้อมูลที่ส่งให้สมองกลอ่านในรอบนั้น ซึ่งอาจเป็นเพียงข้อความคำถามเดี่ยว ๆ หรือเป็นเอกสารที่ระบบนำ Message, ประวัติการคุย, และข้อมูลประกอบมาจัดเตรียมเข้าด้วยกัน
  • Model / Brain (สมองกล): เครื่องจักรประมวลผลที่ทำหน้าที่เป็นกล่องดำ รับ Prompt เข้าไป แล้วสร้างคำตอบกลับมา
  • Response / Completion (ผลลัพธ์คำตอบ): ข้อความที่สมองกลสร้างต่อเติมกลับคืนมา เพื่อตอบสนองต่อโจทย์ใน Prompt
หลักคิดเชิงสถาปัตยกรรม — แตะเพื่อย่อ/ขยาย
  • เข้าใจระดับของ Prompt (Message vs Assembled Prompt): ในการใช้งานทั่วไป ข้อความที่เราพิมพ์ก็คือ User Prompt แต่ในมุมสถาปัตยกรรมระบบ สถาปนิกจะมองเห็นว่า Prompt ที่ส่งเข้าโมเดลมักเกิดจากการที่ระบบหลังบ้านช่วยนำข้อความของผู้ใช้ไปประกอบร่างเข้ากับบริบท กฎเกณฑ์ และประวัติการคุย เพื่อให้โมเดลตอบได้แม่นยำที่สุด
  • มองสมองกลเป็น Black Box: สถาปนิกซอฟต์แวร์ไม่จำเป็นต้องรู้ลึกถึงสูตรคณิตศาสตร์หรือการทำงานภายในของโมเดล สิ่งสำคัญคือความเข้าใจในสัญญาการทำงาน (Contract): ป้อน Prompt แบบไหน และมันจะสร้าง Response อะไรกลับมา
  • ออกแบบระบบเพื่อลดภาระผู้ใช้: ระบบที่ดีจะรับหน้าที่หนักในการประกอบร่าง Prompt ยาว ๆ ที่ซับซ้อนอยู่เบื้องหลัง เพื่อให้ผู้ใช้งานพิมพ์เพียง Message สั้น ๆ ที่ชัดเจนและตรงประเด็นก็สามารถทำงานได้สำเร็จครับ