Prompt API की मदद से अनुमान लगाने वाला गेम बनाना

Brecht De Ruyte

पब्लिश होने की तारीख: 10 अक्टूबर, 2025

क्लासिक बोर्ड गेम, Guess Who?, तार्किक सोच को बेहतर बनाने के लिए एक बेहतरीन गेम है. हर खिलाड़ी के पास चेहरों वाला एक बोर्ड होता है. इसके बाद, हां या नहीं में जवाब दिए जाने वाले सवालों की एक सीरीज़ के ज़रिए, संभावित चेहरों की संख्या कम की जाती है. ऐसा तब तक किया जाता है, जब तक आपको अपने विरोधी के सीक्रेट कैरेक्टर की पहचान न हो जाए.

Google I/O Connect में, पहले से मौजूद एआई का डेमो देखने के बाद, मेरे मन में यह सवाल आया: अगर मुझे ब्राउज़र में मौजूद एआई के साथ Guess Who? गेम खेलने का मौका मिले, तो क्या होगा? क्लाइंट-साइड एआई की मदद से, फ़ोटो को स्थानीय तौर पर प्रोसेस किया जाएगा. इसलिए, दोस्तों और परिवार के सदस्यों की फ़ोटो से बनाया गया 'पहचानो कौन?' गेम मेरे डिवाइस पर निजी और सुरक्षित रहेगा.

मेरा बैकग्राउंड मुख्य रूप से यूज़र इंटरफ़ेस (यूआई) और उपयोगकर्ता अनुभव (यूएक्स) डेवलपमेंट में है. साथ ही, मुझे पिक्सल-परफ़ेक्ट अनुभव बनाने की आदत है. मुझे उम्मीद है कि मैंने अपनी व्याख्या में ऐसा ही किया है.

मेरा ऐप्लिकेशन, AI Guess Who?, React की मदद से बनाया गया है. इसमें Prompt API और ब्राउज़र में पहले से मौजूद मॉडल का इस्तेमाल किया जाता है, ताकि एक दमदार विरोधी तैयार किया जा सके. इस प्रोसेस में, मुझे पता चला कि "पूरी तरह से सटीक" नतीजे पाना इतना आसान नहीं है. हालांकि, इस ऐप्लिकेशन से पता चलता है कि एआई का इस्तेमाल करके, गेम के लॉजिक को कैसे बेहतर बनाया जा सकता है. साथ ही, इस लॉजिक को बेहतर बनाने और मनमुताबिक नतीजे पाने के लिए, प्रॉम्प्ट इंजीनियरिंग कितनी ज़रूरी है.

एआई इंटिग्रेशन की सुविधा के बारे में जानने के लिए, पढ़ना जारी रखें. साथ ही, मुझे जिन चुनौतियों का सामना करना पड़ा और मैंने जिन समाधानों का इस्तेमाल किया उनके बारे में भी जानें. गेम खेला जा सकता है. साथ ही, GitHub पर सोर्स कोड देखा जा सकता है.

गेम फ़ाउंडेशन: एक React ऐप्लिकेशन

एआई को लागू करने से पहले, हम ऐप्लिकेशन के स्ट्रक्चर की समीक्षा करेंगे. मैंने TypeScript की मदद से एक स्टैंडर्ड React ऐप्लिकेशन बनाया है. इसमें एक App.tsx फ़ाइल है, जो गेम को कंट्रोल करती है. इस फ़ाइल में यह जानकारी होती है:

• गेम की स्थिति: यह एक इनम है, जो गेम के मौजूदा फ़ेज़ को ट्रैक करता है. जैसे, PLAYER_TURN_ASKING, AI_TURN, GAME_OVER. यह सबसे अहम स्थिति होती है, क्योंकि इससे यह तय होता है कि इंटरफ़ेस क्या दिखाता है और खिलाड़ी के लिए कौनसी कार्रवाइयां उपलब्ध हैं.
• वर्णों की सूचियां: ऐसी कई सूचियां होती हैं जो सक्रिय वर्णों, हर खिलाड़ी के सीक्रेट वर्ण, और बोर्ड से हटाए गए वर्णों के बारे में बताती हैं.
• गेम चैट: इसमें सवालों, जवाबों, और सिस्टम मैसेज का लॉग दिखता है.

इंटरफ़ेस को लॉजिकल कॉम्पोनेंट में बांटा गया है:

गेम की सुविधाओं के बढ़ने के साथ-साथ, इसे इस्तेमाल करना भी मुश्किल होता गया. शुरुआत में, पूरे गेम के लॉजिक को एक बड़े कस्टम React हुक, useGameLogic में मैनेज किया गया था. हालांकि, यह बहुत बड़ा हो गया था, इसलिए इसे नेविगेट करना और डीबग करना मुश्किल हो गया था. इस हुक को कई हुक में फिर से फ़ैक्टर किया गया है, ताकि इसे बनाए रखना आसान हो. हर हुक की एक ही ज़िम्मेदारी है. उदाहरण के लिए:

• useGameState मुख्य स्थिति को मैनेज करता है
• usePlayerActions का इस्तेमाल, खिलाड़ी की बारी के लिए किया जाता है
• useAIActions, एआई के लॉजिक के लिए है

अब मुख्य useGameLogic हुक, एक कंपोज़र की तरह काम करता है. यह इन छोटे हुक को एक साथ रखता है. आर्किटेक्चर में हुए इस बदलाव से, गेम के फ़ंक्शन में कोई बदलाव नहीं हुआ. हालांकि, इससे कोडबेस काफ़ी बेहतर हो गया.

Prompt API की मदद से गेम लॉजिक

इस प्रोजेक्ट का मुख्य हिस्सा, Prompt API का इस्तेमाल करना है.

मैंने builtInAIService.ts में एआई गेम लॉजिक जोड़ा है. इसकी मुख्य ज़िम्मेदारियां ये हैं:

1. पाबंदी वाले, बाइनरी जवाबों की अनुमति दें.
2. मॉडल को गेम की रणनीति सिखाएं.
3. मॉडल को विश्लेषण करना सिखाएं.
4. मॉडल को भूलने की बीमारी हो जाती है.

पाबंदी वाले, हां या नहीं में जवाब देने की अनुमति दें

खिलाड़ी, एआई के साथ कैसे इंटरैक्ट करता है? जब कोई खिलाड़ी पूछता है कि "क्या आपके किरदार ने टोपी पहनी है?", तो एआई को अपने सीक्रेट किरदार की इमेज को "देखना" होगा और साफ़ तौर पर जवाब देना होगा.

शुरुआत में, मुझसे ठीक से जवाब नहीं बन पा रहे थे. जवाब बातचीत के तरीके में दिया गया था: "नहीं, मैंने जिस किरदार के बारे में सोचा है, वह इसाबेला है. उसने टोपी नहीं पहनी है." इसके बजाय, जवाब में सिर्फ़ "हाँ" या "नहीं" होना चाहिए था. शुरू में, मैंने इस समस्या को हल करने के लिए बहुत सख्त प्रॉम्प्ट का इस्तेमाल किया. इसमें मैंने मॉडल को सिर्फ़ "हाँ" या "नहीं" में जवाब देने का निर्देश दिया.

हालांकि, इससे काम हो गया, लेकिन मुझे स्ट्रक्चर्ड आउटपुट का इस्तेमाल करके, इससे भी बेहतर तरीका पता चला. मॉडल को JSON स्कीमा उपलब्ध कराकर, सही या गलत जवाब की गारंटी दी जा सकती है.

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

इससे मुझे प्रॉम्प्ट को आसान बनाने में मदद मिली. साथ ही, मेरे कोड को भरोसेमंद तरीके से जवाब मैनेज करने की सुविधा मिली:

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

मॉडल को गेम की रणनीति सिखाना

मॉडल को किसी सवाल का जवाब देने के लिए कहना, मॉडल को सवाल पूछने के लिए कहने से ज़्यादा आसान है. Guess Who? गेम का अच्छा खिलाड़ी, बिना सोचे-समझे सवाल नहीं पूछता. ये ऐसे सवाल पूछते हैं जिनसे एक बार में ज़्यादा से ज़्यादा वर्णों को हटाया जा सके. सबसे सही सवाल वह होता है जिसमें बाइनरी सवालों का इस्तेमाल करके, जवाब के लिए बचे हुए विकल्पों को आधा कर दिया जाता है.

किसी मॉडल को यह रणनीति कैसे सिखाई जाती है? फिर से, प्रॉम्प्ट इंजीनियरिंग. generateAIQuestion() के लिए दिया गया प्रॉम्प्ट, 'Guess Who?' गेम थ्योरी का एक छोटा सा सबक है.

शुरुआत में, मैंने मॉडल से "एक अच्छा सवाल पूछने" के लिए कहा. नतीजे अनुमान के मुताबिक नहीं थे. नतीजों को बेहतर बनाने के लिए, मैंने नेगेटिव कंस्ट्रेंट जोड़े हैं. प्रॉम्प्ट में अब इस तरह के निर्देश शामिल हैं:

• "CRITICAL: Ask about existing features ONLY"
• "CRITICAL: Be original. किसी सवाल को न दोहराएं".

इन शर्तों की वजह से, मॉडल का फ़ोकस सीमित हो जाता है. साथ ही, यह मॉडल ऐसे सवाल नहीं पूछता जो गेम से जुड़े न हों. इससे गेम खेलने में ज़्यादा मज़ा आता है. GitHub पर मौजूद पूरी प्रॉम्प्ट फ़ाइल देखी जा सकती है.

मॉडल को विश्लेषण करना सिखाना

यह अब तक की सबसे मुश्किल और अहम चुनौती थी. जब मॉडल कोई सवाल पूछता है, जैसे कि "क्या आपके किरदार ने टोपी पहनी है" और खिलाड़ी जवाब देता है कि नहीं, तो मॉडल को यह कैसे पता चलता है कि बोर्ड पर मौजूद किन किरदारों को हटा दिया गया है?

मॉडल को, हैट पहने हुए सभी लोगों को हटा देना चाहिए. शुरुआत में, मुझे लॉजिकल गड़बड़ियों का सामना करना पड़ा. साथ ही, कभी-कभी मॉडल ने गलत वर्णों को हटा दिया या किसी भी वर्ण को नहीं हटाया. इसके अलावा, "हैट" क्या होता है? क्या "बीनी" को "हैट" माना जाता है? ईमानदारी से कहें, तो ऐसा इंसानों के बीच होने वाली बहस में भी हो सकता है. इसके अलावा, सामान्य गलतियां भी होती हैं. एआई की नज़र से बाल, टोपी की तरह दिख सकते हैं.

मैंने आर्किटेक्चर को फिर से डिज़ाइन किया है, ताकि कोड डिडक्शन को परसेप्शन से अलग किया जा सके:

1. इमेज का विश्लेषण करने की ज़िम्मेदारी एआई की होती है. मॉडल, विज़ुअल विश्लेषण में बेहतर होते हैं. मैंने मॉडल को निर्देश दिया है कि वह अपने सवाल और उसके बारे में पूरी जानकारी को JSON स्कीमा में दिखाए. मॉडल अपने बोर्ड पर मौजूद हर वर्ण का विश्लेषण करता है और इस सवाल का जवाब देता है कि "क्या इस वर्ण में यह सुविधा है?" मॉडल, स्ट्रक्चर्ड JSON ऑब्जेक्ट दिखाता है:

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

   एक बार फिर, स्ट्रक्चर्ड डेटा की मदद से बेहतर नतीजे पाए जा सकते हैं.

2. गेम कोड, विश्लेषण का इस्तेमाल करके फ़ाइनल फ़ैसला लेता है. ऐप्लिकेशन कोड, खिलाड़ी के जवाब ("हां" या "नहीं") की जांच करता है और एआई के विश्लेषण को दोहराता है. अगर खिलाड़ी ने "नहीं" कहा, तो कोड को पता चल जाता है कि उसे हर उस वर्ण को हटाना है जहां has_feature, true है.

मुझे लगता है कि काम को इस तरह से बांटने से, भरोसेमंद एआई ऐप्लिकेशन बनाने में मदद मिलती है. एआई का इस्तेमाल, डेटा का विश्लेषण करने के लिए करें. साथ ही, बाइनरी फ़ैसले लेने का काम अपने ऐप्लिकेशन कोड पर छोड़ दें.

मॉडल की परसेप्शन की जांच करने के लिए, मैंने इस विश्लेषण का विज़ुअलाइज़ेशन बनाया. इससे यह पुष्टि करना आसान हो गया कि मॉडल की धारणा सही थी या नहीं.

प्रॉम्प्ट इंजीनियरिंग

हालांकि, अलग-अलग करने के बाद भी, मुझे लगा कि मॉडल की सोच में अब भी कुछ कमियां हो सकती हैं. ऐसा हो सकता है कि यह सुविधा, किसी किरदार के चश्मा पहनने के बारे में गलत अनुमान लगाए. इस वजह से, किरदार को गलत तरीके से हटा दिया जाता है. इस समस्या को हल करने के लिए, मैंने दो चरणों वाली प्रोसेस का इस्तेमाल किया: एआई अपना सवाल पूछता. खिलाड़ी का जवाब मिलने के बाद, यह जवाब को कॉन्टेक्स्ट के तौर पर इस्तेमाल करके, दूसरी बार नया विश्लेषण करेगा. ऐसा माना जाता था कि दूसरी बार देखने पर, पहली बार में हुई गड़बड़ियां पकड़ी जा सकती हैं.

यहां बताया गया है कि यह फ़्लो कैसे काम करता है:

1. एआई का जवाब (एपीआई कॉल 1): एआई पूछता है, "क्या आपके कैरेक्टर की दाढ़ी है?"
2. खिलाड़ी की बारी: खिलाड़ी अपने सीक्रेट किरदार को देखता है. इस किरदार की दाढ़ी नहीं है. इसलिए, वह जवाब देता है, "नहीं."
3. एआई की बारी (एपीआई कॉल 2): एआई, अपने सभी बचे हुए वर्णों को फिर से देखने के लिए कहता है. साथ ही, खिलाड़ी के जवाब के आधार पर यह तय करता है कि किन वर्णों को हटाना है.

दूसरे चरण में, मॉडल अब भी हल्की दाढ़ी वाले व्यक्ति को "बिना दाढ़ी वाला" मान सकता है और उसे नहीं हटा सकता. भले ही, उपयोगकर्ता ने ऐसा करने के लिए कहा हो. परसेप्शन से जुड़ी मुख्य गड़बड़ी को ठीक नहीं किया गया. साथ ही, अतिरिक्त चरण से सिर्फ़ नतीजे मिलने में देरी हुई. किसी इंसान के ख़िलाफ़ गेम खेलते समय, हम इस बारे में सहमति ले सकते हैं या साफ़ तौर पर बता सकते हैं. हालांकि, एआई के ख़िलाफ़ गेम खेलते समय ऐसा नहीं किया जा सकता.

इस प्रोसेस से, दूसरे एपीआई कॉल में देरी हुई. हालांकि, इससे सटीक जवाब मिलने की संभावना में कोई खास बढ़ोतरी नहीं हुई. अगर मॉडल ने पहली बार गलत जवाब दिया, तो अक्सर दूसरी बार भी गलत जवाब दिया. मैंने प्रॉम्प्ट को सिर्फ़ एक बार समीक्षा करने के लिए वापस ला दिया है.

ज़्यादा विश्लेषण करने के बजाय, जवाब को बेहतर बनाओ

मैंने यूज़र एक्सपीरियंस के एक सिद्धांत का इस्तेमाल किया: समस्या का समाधान ज़्यादा विश्लेषण नहीं था, बल्कि बेहतर विश्लेषण था.

मैंने प्रॉम्प्ट को बेहतर बनाने के लिए काफ़ी समय दिया. साथ ही, मॉडल को अपने काम की दोबारा जांच करने और अलग-अलग सुविधाओं पर फ़ोकस करने के लिए साफ़ तौर पर निर्देश जोड़े. इससे, जवाबों को ज़्यादा सटीक बनाने में मदद मिली. यहां बताया गया है कि मौजूदा और ज़्यादा भरोसेमंद फ़्लो कैसे काम करता है:

1. एआई टर्न (एपीआई कॉल): मॉडल को एक ही समय में अपना सवाल और उसका विश्लेषण जनरेट करने के लिए कहा जाता है. इससे एक JSON ऑब्जेक्ट मिलता है.

   1. सवाल: "क्या आपके किरदार ने चश्मा पहना है?"
   2. विश्लेषण (डेटा):

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

2. खिलाड़ी की बारी: खिलाड़ी का सीक्रेट किरदार ऐलेक्स है (बिना चश्मे वाला), इसलिए वह जवाब देता है, "नहीं."

3. राउंड खत्म होता है: ऐप्लिकेशन का JavaScript कोड काम करना शुरू कर देता है. इसे एआई से कुछ और पूछने की ज़रूरत नहीं है. यह पहले चरण के विश्लेषण डेटा को दोहराता है.

   1. खिलाड़ी ने कहा, "नहीं."
   2. यह कोड, हर उस वर्ण को खोजता है जहां has_feature सही है.
   3. इसमें ब्रैड और जीना को नीचे की ओर फ़्लिप करते हुए दिखाया गया है. यह लॉजिक, तय किए गए नियमों के हिसाब से काम करता है और तुरंत नतीजे देता है.

यह एक्सपेरिमेंट बहुत ज़रूरी था, लेकिन इसके लिए कई बार कोशिश करनी पड़ी. मुझे नहीं पता था कि यह ठीक होगा या नहीं. कभी-कभी, यह स्थिति और भी खराब हो जाती है. सबसे सटीक नतीजे पाने का तरीका तय करना, कोई सटीक विज्ञान नहीं है.

हालांकि, एआई के साथ कुछ राउंड खेलने के बाद, एक नई समस्या सामने आई: गेम ड्रॉ हो गया.

डेडलॉक से बाहर निकलना

जब सिर्फ़ दो या तीन मिलते-जुलते वर्ण बचे होते थे, तो मॉडल एक लूप में फंस जाता था. यह एक ऐसी सुविधा के बारे में सवाल पूछता है जो सभी कैरेक्टर में मौजूद होती है. जैसे, "क्या आपके कैरेक्टर ने हैट पहनी है?"

मेरा कोड इसे एक बेकार टर्न के तौर पर सही तरीके से पहचान लेगा. इसके बाद, एआई एक और ऐसी सुविधा आज़माएगा जो सभी वर्णों के लिए भी उपलब्ध हो. जैसे, "क्या आपके किरदार ने चश्मा पहना है?"

मैंने प्रॉम्प्ट में एक नया नियम जोड़ा है: अगर सवाल जनरेट करने की कोशिश विफल हो जाती है और तीन या इससे कम वर्ण बचे हैं, तो रणनीति बदल जाएगी.

नए निर्देश में साफ़ तौर पर बताया गया है कि "किसी सामान्य सुविधा के बारे में पूछने के बजाय, आपको किसी खास, यूनीक या एक साथ कई सुविधाओं के बारे में पूछना होगा, ताकि दोनों इमेज के बीच का अंतर पता चल सके." उदाहरण के लिए, कैरेक्टर ने हैट पहनी है या नहीं, यह पूछने के बजाय, उससे पूछा जाता है कि उसने बेसबॉल कैप पहनी है या नहीं.

इससे मॉडल को इमेज को ज़्यादा बारीकी से देखने के लिए मजबूर किया जाता है, ताकि वह एक छोटी सी जानकारी ढूंढ सके. इससे आखिर में, मॉडल को सफलता मिल सकती है. साथ ही, इससे गेम के आखिरी हिस्से में मॉडल की रणनीति ज़्यादातर समय बेहतर तरीके से काम करती है.

मॉडल को भूलने की बीमारी हो जाती है

किसी लैंग्वेज मॉडल की सबसे बड़ी ताकत उसकी मेमोरी होती है. हालांकि, इस गेम में यह खूबी, कमज़ोरी बन गई. दूसरा गेम शुरू करने पर, यह ऐसे सवाल पूछता था जो समझ से परे थे या जिनका कोई मतलब नहीं था. ज़ाहिर है, मेरे स्मार्ट एआई विरोधी ने पिछले गेम की पूरी चैट हिस्ट्री सेव की थी. यह एक साथ दो या उससे ज़्यादा गेम को समझने की कोशिश कर रहा था.

अब मैं हर गेम के आखिर में, एक ही एआई सेशन का दोबारा इस्तेमाल करने के बजाय, उसे साफ़ तौर पर नष्ट कर देता हूं. इससे एआई को भूलने की बीमारी हो जाती है.

फिर से खेलें पर क्लिक करने पर, startNewGameSession() फ़ंक्शन बोर्ड को रीसेट कर देता है और एआई का एक नया सेशन शुरू करता है. यह सेशन की स्थिति को मैनेज करने के बारे में एक दिलचस्प सबक था. यह न सिर्फ़ ऐप्लिकेशन में, बल्कि एआई मॉडल में भी लागू होता है.

खास सुविधाएं: कस्टम गेम और बोलकर निर्देश देने की सुविधा

मैंने इस सुविधा को और भी दिलचस्प बनाने के लिए, दो और सुविधाएं जोड़ी हैं:

1. कस्टम कैरेक्टर: getUserMedia() की मदद से, खिलाड़ी अपने कैमरे का इस्तेमाल करके पांच कैरेक्टर का सेट बना सकते हैं. मैंने वर्णों को सेव करने के लिए IndexedDB का इस्तेमाल किया. यह ब्राउज़र डेटाबेस, इमेज ब्लोब जैसे बाइनरी डेटा को सेव करने के लिए सबसे सही है. कस्टम सेट बनाने पर, यह आपके ब्राउज़र में सेव हो जाता है. साथ ही, मुख्य मेन्यू में फिर से चलाने का विकल्प दिखता है.

2. बोलकर निर्देश देना: क्लाइंट-साइड मॉडल मल्टी-मॉडल होता है. यह टेक्स्ट, इमेज, और ऑडियो को भी समझ सकता है. माइक्रोफ़ोन से मिले इनपुट को कैप्चर करने के लिए, MediaRecorder API का इस्तेमाल किया गया. इसके बाद, ऑडियो ब्Blob को मॉडल में प्रॉम्प्ट के साथ डाला गया: "इस ऑडियो को ट्रांसक्राइब करो...". इससे गेम खेलने का एक मज़ेदार तरीका मिलता है. साथ ही, यह देखने का भी एक मज़ेदार तरीका मिलता है कि यह मेरे फ़्लेमिश लहज़े को कैसे समझता है. मैंने इसे मुख्य रूप से इस नई वेब सुविधा की वर्सटैलिटी दिखाने के लिए बनाया है. हालांकि, सच यह है कि मैं बार-बार सवाल टाइप करके थक गया था.

डेमो

गेम को सीधे तौर पर यहां आज़माया जा सकता है या नई विंडो में खेला जा सकता है. साथ ही, GitHub पर सोर्स कोड देखा जा सकता है.

आखिर में कुछ ज़रूरी बातें

"AI Guess Who?" को बनाना वाकई एक चुनौती थी. हालांकि, दस्तावेज़ पढ़ने और एआई को डीबग करने के लिए कुछ एआई की मदद से (हां... मैंने ऐसा किया), यह एक मज़ेदार एक्सपेरिमेंट साबित हुआ. इससे यह पता चला कि ब्राउज़र में मॉडल चलाने से, निजी, तेज़, और बिना इंटरनेट के काम करने वाला अनुभव मिलता है. यह सुविधा अब भी एक्सपेरिमेंट के तौर पर उपलब्ध है. इसलिए, ऐसा हो सकता है कि कभी-कभी विरोधी खिलाड़ी सही तरीके से न खेले. यह पिक्सल-परफ़ेक्ट या लॉजिक-परफ़ेक्ट नहीं है. जनरेटिव एआई के ज़रिए मिले नतीजे, मॉडल पर निर्भर करते हैं.

मैं परफ़ेक्शन के बजाय, बेहतर नतीजे पाने पर ध्यान दूंगा.

इस प्रोजेक्ट से, प्रॉम्प्ट इंजीनियरिंग से जुड़ी लगातार आने वाली चुनौतियों के बारे में भी पता चला. प्रॉम्प्टिंग, इस गेम का एक अहम हिस्सा बन गई थी. हालांकि, यह हमेशा मज़ेदार नहीं होती थी. हालांकि, मैंने सबसे ज़रूरी यह सीखा कि ऐप्लिकेशन को इस तरह से डिज़ाइन किया जाए कि वह अनुमान लगाने और तर्क करने की क्षमता को अलग-अलग कर सके. साथ ही, एआई और कोड की क्षमताओं को अलग-अलग कर सके. इन दोनों को अलग-अलग रखने के बावजूद, मुझे पता चला कि एआई अब भी ऐसी गलतियां कर सकता है जो किसी इंसान को साफ़ तौर पर दिखती हैं. जैसे, टैटू को मेकअप समझना या यह भूल जाना कि किस किरदार के सीक्रेट कैरेक्टर के बारे में बात की जा रही है.

हर बार, प्रॉम्प्ट को और भी ज़्यादा साफ़ तौर पर बताया गया. साथ ही, ऐसे निर्देश जोड़े गए जो किसी इंसान के लिए सामान्य हैं, लेकिन मॉडल के लिए ज़रूरी हैं.

कभी-कभी, गेम में ऐसा लगता था कि आपके साथ सही बर्ताव नहीं किया गया. कभी-कभी मुझे ऐसा लगता था कि एआई को पहले से ही सीक्रेट कैरेक्टर के बारे में "पता" था. भले ही, कोड में उस जानकारी को साफ़ तौर पर कभी शेयर नहीं किया गया था. इससे यह पता चलता है कि मशीन और इंसान में क्या अंतर है:

एआई का व्यवहार सिर्फ़ सही नहीं होना चाहिए, बल्कि निष्पक्ष भी होना चाहिए.

इसलिए, मैंने प्रॉम्प्ट को अपडेट किया है. इनमें साफ़ तौर पर निर्देश दिए गए हैं. जैसे, "तुम्हें यह नहीं पता कि मैंने कौनसी इमेज चुनी है" और "धोखाधड़ी नहीं करनी है." मुझे पता चला कि एआई एजेंट बनाते समय, आपको सीमाओं को तय करने में समय बिताना चाहिए. शायद निर्देशों से भी ज़्यादा.

मॉडल के साथ इंटरैक्शन को बेहतर बनाया जा सकता है. डिवाइस में पहले से मौजूद मॉडल का इस्तेमाल करने से, आपको सर्वर-साइड पर मौजूद बड़े मॉडल की कुछ सुविधाएं और भरोसेमंद नतीजे नहीं मिलते. हालांकि, आपको निजता, तेज़ प्रोसेसिंग, और ऑफ़लाइन काम करने की सुविधा मिलती है. इस तरह के गेम के लिए, यह समझौता वाकई में एक्सपेरिमेंट करने लायक था. क्लाइंट-साइड एआई का भविष्य हर दिन बेहतर होता जा रहा है. साथ ही, मॉडल भी छोटे होते जा रहे हैं. हमें यह देखने का बेसब्री से इंतज़ार है कि हम आगे क्या बना पाएंगे.