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

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

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

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

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

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

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

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

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

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