สร้างเกมทายคำด้วย 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 โดยไม่ได้เพิ่มความแม่นยำอย่างมีนัยสำคัญ หากโมเดลไม่ถูกต้องในครั้งแรก ก็มักจะไม่ถูกต้องในครั้งที่สองด้วย ฉันได้เปลี่ยนข้อความแจ้งให้ตรวจสอบเพียงครั้งเดียวแล้ว

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

ฉันยึดหลัก 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 รอบ ปัญหาใหม่ที่ยอดเยี่ยมก็ปรากฏขึ้น นั่นคือ การเสมอกัน

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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