สร้างเกมทายคำด้วย Prompt API

Brecht De Ruyte

เผยแพร่: 10 ตุลาคม 2025

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

หลังจากได้ดูเดโมของ AI ในตัวที่ Google I/O Connect ฉันก็สงสัยว่าจะเป็นอย่างไรหากฉันเล่นเกมทายชื่อกับ AI ที่อยู่ใน เบราว์เซอร์ได้ AI ฝั่งไคลเอ็นต์จะตีความรูปภาพในเครื่อง ดังนั้นเกมทายใครเอ่ยที่กำหนดเองของเพื่อนและครอบครัวจะยังคงเป็นส่วนตัวและปลอดภัยในอุปกรณ์ของฉัน

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

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

อ่านต่อเพื่อดูข้อมูลเกี่ยวกับการผสานรวม AI ในตัว ความท้าทายที่ฉันพบ และ โซลูชันที่ฉันใช้ คุณสามารถเล่นเกมและดูซอร์สโค้ดใน GitHub ได้

รากฐานของเกม: แอป React

ก่อนที่จะดูการติดตั้งใช้งาน AI เราจะตรวจสอบโครงสร้างของแอปพลิเคชัน ฉันสร้างแอปพลิเคชัน React มาตรฐานด้วย TypeScript โดยมีApp.tsxไฟล์ส่วนกลางเพื่อทำหน้าที่เป็นตัวควบคุมเกม ไฟล์นี้ประกอบด้วย

• สถานะเกม: Enum ที่ติดตามเฟสปัจจุบันของเกม (เช่น PLAYER_TURN_ASKING, AI_TURN, GAME_OVER) นี่คือสถานะที่สำคัญที่สุด เนื่องจากเป็นตัวกำหนดว่าอินเทอร์เฟซจะแสดงอะไรและผู้เล่นจะทำอะไรได้บ้าง
• รายการตัวละคร: มีรายการหลายรายการที่ระบุตัวละครที่ใช้งานอยู่ ตัวละครลับของผู้เล่นแต่ละคน และตัวละครที่ถูกกำจัดออกจากกระดาน
• แชทในเกม: บันทึกคำถาม คำตอบ และข้อความของระบบที่กำลังดำเนินการ

อินเทอร์เฟซแบ่งออกเป็นคอมโพเนนต์เชิงตรรกะดังนี้

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

• useGameState จัดการสถานะหลัก
• usePlayerActions คือตาของผู้เล่น
• useAIActions มีไว้สำหรับตรรกะของ AI

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

ตรรกะของเกมด้วย Prompt API

หัวใจหลักของโปรเจ็กต์นี้คือการใช้ Prompt API

ฉันได้เพิ่มตรรกะของเกม AI ลงใน builtInAIService.ts แล้ว โดยมีหน้าที่หลักดังนี้

1. อนุญาตคำตอบแบบไบนารีที่จำกัด
2. สอนกลยุทธ์เกมโมเดล
3. สอนการวิเคราะห์โมเดล
4. ทำให้โมเดลลืม

อนุญาตคำตอบแบบไบนารีที่จำกัด

ผู้เล่นโต้ตอบกับ AI อย่างไร เมื่อผู้เล่นถามว่า "ตัวละครของคุณ สวมหมวกไหม" AI ต้อง "ดู" รูปภาพตัวละครลับ และตอบคำถามอย่างชัดเจน

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

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

const schema = { type: "boolean" };
const result = session.prompt(prompt, { responseConstraint: schema });

ซึ่งช่วยให้ฉันลดความซับซ้อนของพรอมต์และให้โค้ดจัดการคำตอบได้อย่างน่าเชื่อถือ

JSON.parse(result) ? "Yes" : "No"

สอนกลยุทธ์เกมให้โมเดล

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

คุณจะสอนกลยุทธ์นั้นให้โมเดลได้อย่างไร อีกครั้ง วิศวกรรมพรอมต์ พรอมต์ สำหรับgenerateAIQuestion()เป็นบทเรียนสั้นๆ เกี่ยวกับทฤษฎีเกม Guess Who?

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

• "สำคัญ: ถามเกี่ยวกับฟีเจอร์ที่มีอยู่เท่านั้น"
• "สำคัญ: สร้างสรรค์ผลงานที่เป็นตัวคุณ อย่าถามคำถามซ้ำ"

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

สอนการวิเคราะห์โมเดล

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

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

ฉันออกแบบสถาปัตยกรรมใหม่เพื่อแยกการรับรู้จากการอนุมานโค้ด

1. AI มีหน้าที่วิเคราะห์ภาพ โมเดลมีความสามารถในการวิเคราะห์ภาพ ฉันสั่งให้โมเดลส่งคำถามและการวิเคราะห์โดยละเอียดใน สคีมา JSON ที่เข้มงวด โมเดลจะวิเคราะห์ตัวละครแต่ละตัวบนกระดานและตอบคำถามที่ว่า "ตัวละครนี้มีฟีเจอร์นี้ไหม" โมเดลจะแสดงผล ออบเจ็กต์ JSON ที่มีโครงสร้างดังนี้

   { "character_id": "...", "has_feature": true }
   

   อีกครั้งที่ Structured Data เป็นกุญแจสำคัญสู่ผลลัพธ์ที่ประสบความสำเร็จ

2. โค้ดเกมใช้การวิเคราะห์เพื่อทำการตัดสินใจขั้นสุดท้าย โค้ดแอปพลิเคชัน จะตรวจสอบคำตอบของผู้เล่น ("ใช่" หรือ "ไม่") และวนซ้ำการวิเคราะห์ของ AI หากผู้เล่นตอบว่า "ไม่" โค้ดจะทราบว่าต้องตัดอักขระทุกตัว ที่ has_feature เป็น true

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

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

วิศวกรรมพรอมต์

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

โดยขั้นตอนการทำงานมีดังนี้

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

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

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

ปรับปรุงแทนที่จะเพิ่มการวิเคราะห์

ฉันจึงยึดหลัก UX ที่ว่าโซลูชันไม่ใช่การวิเคราะห์เพิ่มเติม แต่เป็นการวิเคราะห์ที่ดีขึ้น

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

1. เทิร์นของ AI (การเรียก API): ระบบจะแจ้งให้โมเดลสร้างทั้งคำถาม และการวิเคราะห์ภายในพร้อมกัน โดยจะแสดงผลเป็นออบเจ็กต์ JSON เดียว

   1. คำถาม: "ตัวละครของคุณใส่แว่นไหม"
   2. การวิเคราะห์ (ข้อมูล):

   [
     {character_id: 'brad', has_feature: true},
     {character_id: 'alex', has_feature: false},
     {character_id: 'gina', has_feature: true},
     ...
   ]
   

2. ตาผู้เล่น: ตัวละครลับของผู้เล่นคืออเล็กซ์ (ไม่ใส่แว่น) ดังนั้น ผู้เล่นจึงตอบว่า "ไม่ใช่"

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

   1. ผู้เล่นตอบว่า "ไม่"
   2. โค้ดจะค้นหาอักขระทุกตัวที่ has_feature เป็นจริง
   3. มันพลิกตัวลงมาเป็นแบรดกับจีนา ตรรกะจะกำหนดได้และทำงานทันที

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

แต่หลังจากเล่นกับคู่ต่อสู้ AI คนใหม่ไปได้ไม่กี่รอบ ปัญหาใหม่ที่ยอดเยี่ยมก็ปรากฏขึ้น นั่นคือ การเสมอกัน

หลีกเลี่ยงการติดตาย

เมื่อเหลืออักขระที่คล้ายกันมากเพียง 2-3 ตัว โมเดลจะติดอยู่ในลูป โดยจะถามคำถามเกี่ยวกับฟีเจอร์ที่ตัวละครทั้งหมดมีร่วมกัน เช่น "ตัวละครของคุณสวมหมวกไหม"

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

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

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

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

ทำให้โมเดลลืม

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

ตอนนี้ฉันทำลายเซสชัน AI อย่างชัดเจนเมื่อจบแต่ละเกม ซึ่งทำให้ AI ลืมทุกอย่างไป

เมื่อคลิกเล่นอีกครั้ง ฟังก์ชัน startNewGameSession() จะรีเซ็ตกระดานและสร้างเซสชัน AI ใหม่ นี่เป็นบทเรียนที่น่าสนใจในเรื่องการจัดการสถานะเซสชัน ไม่ใช่แค่ในแอป แต่รวมถึง ภายในโมเดล AI เองด้วย

ลูกเล่นต่างๆ: เกมที่กำหนดเองและการป้อนข้อมูลด้วยเสียง

ฉันจึงเพิ่มฟีเจอร์อีก 2 อย่างเพื่อทำให้ประสบการณ์การใช้งานน่าสนใจยิ่งขึ้น

1. ตัวละครที่กำหนดเอง: ด้วย getUserMedia() ผู้เล่นสามารถใช้กล้องเพื่อสร้างชุดตัวละคร 5 ตัวของตนเองได้ ฉันใช้ IndexedDB เพื่อบันทึกตัวอักขระ ซึ่งเป็นฐานข้อมูลของเบราว์เซอร์ที่เหมาะสำหรับการจัดเก็บ ข้อมูลไบนารี เช่น Blob รูปภาพ เมื่อสร้างชุดที่กำหนดเอง ระบบจะบันทึกชุดนั้นไว้ใน เบราว์เซอร์ และตัวเลือกการเล่นซ้ำจะปรากฏในเมนูหลัก

2. การป้อนข้อมูลด้วยเสียง: โมเดลฝั่งไคลเอ็นต์เป็นแบบหลายรูปแบบ โดยสามารถจัดการข้อความ รูปภาพ และเสียงได้ การใช้ MediaRecorder API เพื่อ บันทึกอินพุตจากไมโครโฟนทำให้ฉันป้อน Blob เสียงที่ได้ไปยังโมเดล พร้อมพรอมต์ "ถอดเสียงต่อไปนี้..." ได้ ซึ่งเป็นวิธีที่สนุกในการเล่น (และเป็นวิธีที่สนุกในการดูว่าฟีเจอร์นี้ตีความสำเนียงเฟลมิชของฉันอย่างไร) เราสร้างฟีเจอร์นี้ขึ้นมา เพื่อแสดงความสามารถที่หลากหลายของความสามารถใหม่บนเว็บนี้เป็นหลัก แต่จริงๆ แล้ว เราเบื่อที่จะต้องพิมพ์คำถามซ้ำๆ

สาธิต

คุณสามารถทดสอบเกมได้ที่นี่โดยตรง หรือเล่นในหน้าต่างใหม่และดูซอร์สโค้ดใน GitHub

ความคิดขั้นสุดท้าย

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

แทนที่จะมุ่งมั่นให้สมบูรณ์แบบ ฉันจะมุ่งเน้นที่การปรับปรุงผลลัพธ์

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

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

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

พฤติกรรมของ AI ไม่ได้ต้องถูกต้องเท่านั้น แต่ต้องรู้สึกว่ายุติธรรมด้วย

ด้วยเหตุนี้ ฉันจึงอัปเดตพรอมต์ด้วยคำสั่งตรงๆ เช่น "คุณไม่ รู้ว่าฉันเลือกตัวละครใด" และ "ห้ามโกง" ฉันได้เรียนรู้ว่าเมื่อ สร้างเอเจนต์ AI คุณควรใช้เวลาในการกำหนดข้อจำกัด ซึ่งอาจจะ มากกว่าคำสั่งด้วยซ้ำ

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