शुरुआत से न्यूरल नेटवर्क के साथ काम करना कैसे सीखें और फॉर्मूला का उपयोग करके प्रॉम्प्ट्स सही तरीके से लिखना

सिफारिश: पायथन में स्क्रैच से एक छोटा न्यूरल नेटवर्क बनाएं और प्रॉम्प्ट्स तैयार करने के लिए एकल सूत्र का उपयोग करें। यह आपके वजन अपडेट कैसे होते हैं और प्रॉम्प्ट्स आउटपुट को कैसे निर्देशित करते हैं, इसकी उत्पत्ति है, जिसमें विचारों का परीक्षण करने के लिए एक जीवंत डेटासेट है। कार्य ठोस है: 2–3 लेयर नेटवर्क लागू करें, एक कॉम्पैक्ट ट्रेनिंग लूप चलाएं, और छोटे वैलिडेशन सेट पर त्रुटि मापें। लोग लिखते हैं कि प्रगति तेजी से आती है जब आप प्रत्येक प्रयोग के लिए एक अतिरिक्त चेकलिस्ट और संक्षिप्त विवरण रखते हैं।

सूत्र को विश्वसनीय रूप से लागू करने के लिए, हर कार्य को प्रॉम्प्ट = कार्य + संदर्भ + बाधाएं + शैली + इनपुट + आउटपुट में मैप करें। प्रत्येक अनुरोध के लिए एक टेम्पलेट (टेम्पलेट) का उपयोग करें ताकि परिणाम तुलनीय रहें। सरल कार्यों से शुरू करें और धीरे-धीरे स्केल करें, प्रत्येक पीढ़ी के लिए इनपुट और आउटपुट लॉग करें ताकि सुधार की आवश्यकता कहां है, इसका निरीक्षण कर सकें।

सीखने का मार्ग व्यावहारिक है: एक न्यूनतम पायथन वातावरण सेट करें, एक छोटा डेटासेट बनाएं, और एक बुनियादी ट्रेनिंग लूप बनाएं। मैं डेटा का एक सबसेट (जिनके लेबल) मेमोरी में लोड करता हूं, फॉरवर्ड पास चलाता हूं, और हानि की गणना करता हूं। एक तत्व को एक समय में बदलकर पुनरावृत्ति करें–सक्रियण, लर्निंग रेट, या बैच साइज–और होल्ड-आउट भाग पर परिणामों की तुलना करें। यह दृष्टिकोण प्रयोग को केंद्रित रखता है और आपको स्पष्ट कारण-प्रभाव संबंध देखने में मदद करता है।

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

व्यवहार में, आप पीढ़ियों और विवरणों को जमा करेंगे जिनका आप बाद में ऑडिट कर सकते हैं। मॉडल कैसे दृश्य-जैसे प्रॉम्प्ट्स, कैप्शनों, और वर्णनात्मक पाठ को संभालता है, यह दर्शाने के लिए बिल्लियों और कपड़ों के आसपास डेटा परिदृश्य बनाएं। हानि, सटीकता, और आउटपुट सामंजस्य जैसे मेट्रिक्स ट्रैक करें, और मॉडल जहां सफल होता है या संघर्ष करता है, वहां एनोटेट करें। आपकी प्रणाली की उत्पत्ति इन पुनरावृत्ति राउंड्स में प्रकट होती है, और आप सीखेंगे कि कौन से पैरामीटर गुणवत्ता और स्थिरता को सबसे अधिक प्रभावित करते हैं। इस प्रक्रिया के अंत में, आप प्रॉम्प्ट डिजाइन के लिए एक दोहराने योग्य विधि और नेटवर्क के माध्यम से छोटे परिवर्तनों के कैसे प्रभाव फैलते हैं, इसकी मजबूत अंतर्ज्ञान प्राप्त करते हैं।

यह दृष्टिकोण आपको वास्तविक दुनिया के कार्यों के लिए तैयार रखता है: आप टेम्पलेट को कई डोमेन में अनुकूलित कर सकते हैं, डेटासेट स्विच कर सकते हैं, और नई बाधाओं के अनुरूप सूत्र को परिष्कृत कर सकते हैं। जब आप तैयार हों, तो आप न्यूरल कार्य और प्रॉम्प्टिंग अनुशासन दोनों की महारत प्रदर्शित करने वाले प्रोटोटाइप्स, तुलनाओं, और एनोटेटेड पीढ़ियों का एक संगठित पोर्टफोलियो साझा करेंगे। क्या आपने जो सीखा है, उसे ताजा समस्याओं पर लागू करने और आत्मविश्वास के साथ अपने प्रयोगों को स्केल करने के लिए तैयार हैं?

एक स्पष्ट सीखने का लक्ष्य और न्यूनतम न्यूरल नेटवर्क स्कोप परिभाषित करें

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

एक विशिष्ट सीखने का लक्ष्य सेट करें

एक ही, ठोस उद्देश्य और यथार्थवादी समय सीमा के साथ समस्या को स्पष्ट करें। सटीकता और हानि जैसे मेट्रिक्स परिभाषित करें, और सफलता का संकेत देने वाली थ्रेशोल्ड चुनें (उदाहरण के लिए, होल्ड-आउट सेट पर 70% सटीकता)। पढ़ने के मार्गदर्शन का उपयोग करें ताकि प्रॉम्प्ट सूत्र सुसंगत इनपुट और आउटपुट उत्पन्न करे। अंत में आवश्यक टोकन और फीचर्स निर्दिष्ट करें जो आप ट्रैक करेंगे, और योजना को आज की क्षमताओं तक सीमित रखें। मॉडल लक्ष्य तक पहुंचने के क्षण को कैप्चर करें और परिणाम लॉग करने के बाद ही समायोजित करें। स्कोप को एक कार्य तक सीमित रखें और लक्ष्य पूरा होने तक अतिरिक्त डेटासेट या कार्य न जोड़ें।

एक न्यूनतम न्यूरल नेटवर्क स्कोप परिभाषित करें

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

तत्व	परिभाषा	उदाहरण
सीखने का लक्ष्य	विशिष्ट, मापने योग्य लक्ष्य और समय सीमा	2 दिनों के भीतर 200-सैंपल होल्ड-आउट पर 70% सटीकता
नेटवर्क स्कोप	न्यूनतम आर्किटेक्चर और डेटा फीचर्स	4 हिडन यूनिट्स के साथ 2-लेयर नेट; बाइनरी कार्य
डेटा और टोकन	केवल आवश्यक टोकन और एक छोटा डेटासेट उपयोग करें	100 सैंपल; आवश्यक टोकन हाइलाइटेड
प्रॉम्प्ट्स	सुसंगत आउटपुट प्राप्त करने के लिए निश्चित सूत्र	प्रॉम्प्ट: "फीचर्स X दिए गए, Y वर्गीकृत करें"
मूल्यांकन	प्रति-एपॉच हानि और अंतिम सटीकता	सर्वश्रेष्ठ चेकपॉइंट रिकॉर्डेड और तुलना की गई

न्यूरल नेटवर्क प्रयोगों के लिए एक पुनरुत्पादनीय पायथन वातावरण सेट करें

एक समर्पित प्रोजेक्ट फोल्डर बनाकर, गिट रिपो इनिशियलाइज करके, और कोंडा या वेनव का उपयोग करके वर्चुअल एनवायरनमेंट सक्रिय करके एक साफ सिस्टम से शुरू करें। पायथन को एक विशिष्ट संस्करण (उदाहरण के लिए 3.11.4) पर पिन करें और environment.yml (कोंडा) या requirements.txt (पिप) के साथ निर्भरताओं को लॉक करें। यह सटीक कॉन्फ़िगरेशन का रिकॉर्ड बनाता है ताकि हर प्रतिभागी इसे अपनी मशीन पर पुनरुत्पादित कर सके और स्वतंत्र रूप से काम शुरू कर सके। विज़ुअलाइज़ेशन के लिए, डेटासेट्स में परिणामों की सुसंगत रोशनी सुनिश्चित करने के लिए रंग पैलेट्स को अग्रिम में योजना बनाएं।

निर्भरता प्रबंधन एकल सत्य का स्रोत उपयोग करता है। कविता, पिपेनव, या पिन की गई requirements.txt का उपयोग करके संस्करणों को लॉक करें। प्लेटफॉर्म्स में पायथन को ठीक करने के लिए pyenv या कोंडा का उपयोग करके इंटरप्रेटर को स्थिर सुनिश्चित करें; यह दृष्टिकोण उन टीमों द्वारा उपयोग किया जाता है जिनके लिए पुनरुत्पादन महत्वपूर्ण है, विशेष रूप से मान्यता कार्यों के लिए जहां स्थिरता मायने रखती है। वातावरण को पुनर्सृजित करने के लिए उपयोग किए गए सटीक कमांड दस्तावेज करें और आसान पुनर्सेटअप के लिए फाइल को रिपॉजिटरी में स्टोर करें।

तुलनाओं के लिए निर्धारणवाद महत्वपूर्ण है। बीज सेट करें और निर्धारणवादी संचालन: numpy.random.seed(42), random.seed(42), और torch.manual_seed(42)। पायथॉन में निर्धारणवादी एल्गोरिदम सक्षम करें और जहां संभव हो गैर-निर्धारणवादी CUDA ऑप्स से बचें। यह स्थिर परिणाम सुनिश्चित करता है; हर रन में दोहराने योग्य व्यवहार होता है, जो कार्यों और परिणामों की तुलना में सहायता करता है। संवेदनशील मॉडलों के साथ काम करते समय, लेख के एक समर्पित अनुभाग में किसी भी अपरिहार्य गैर-निर्धारणवाद को नोट करें और बेसलाइन को साफ रखें।

डेटा हैंडलिंग और इमेज पाइपलाइनों को स्पष्टता की आवश्यकता है। पूर्वप्रसंस्करण चरणों को ठीक करें, जहां संभव हो निर्धारणवादी वृद्धि, और पूरी इमेज प्रोसेसिंग चेन रिकॉर्ड करें। मजबूत इमेज लोडिंग का उपयोग करें और इमेजों पर संचालित कार्यों को निर्धारणवादी सुनिश्चित करें। अन्य भाषाओं में श्रोताओं को समायोजित करने के लिए, जहां उपयुक्त हो द्विभाषी रूप में पाइपलाइन दस्तावेज करें, और आउटपुट पुनरुत्पादित करने के लिए डेटा स्प्लिट और बीज का रिकॉर्ड स्टोर करें। यह दृष्टिकोण ग्राहकों को स्थिरता का मूल्यांकन करने में मदद करता है और वातावरणों में ड्रिफ्ट को कम करता है।

प्रयोग ट्रैकिंग और रिपोर्टिंग टीमों को सशक्त बनाती है। टाइमस्टैम्प्स, वातावरण हैश, और हाइपरपैरामीटर्स के साथ रनों का स्थानीय लेजर बनाए रखें। प्लॉट्स और सारांशों में परिणामों की स्पष्ट रोशनी प्रदान करें, और नोट्स को लोगों और ग्राहकों के लिए सुलभ रखें। हर रन को सटीक वातावरण स्थिति और डेटा संस्करण से बांधें, ताकि हर हितधारक कार्यप्रवाह का ऑडिट कर सके और इस लेख में दस्तावेजित परिणामों को पुनरुत्पादित कर सके।

अभी शुरू करने के लिए व्यावहारिक चरण: environment.yml या requirements.txt बनाएं, एक बेसलाइन रैंडम बीज घोषित करें, और पुनरुत्पादन सत्यापित करने के लिए एक छोटा ट्रेनिंग पास टेस्ट करें। अपने डॉक्स में बेसलाइन प्रोजेक्ट का नाम अकिरा (अकीरा) रखें, और निर्भरताओं और वातावरण विवरणों को पिन करने के लिए मेनपलथॉर्प.yaml नामक कॉन्फ़िग फाइल का संदर्भ दें। यदि आप ग्राहकों को दृष्टिकोण बेचने की योजना बना रहे हैं, तो एक पारदर्शी, न्यूनतम पुनरुत्पादन पथ प्रदान करें जिसमें एक रेडी-टू-रन स्क्रिप्ट और चरणों का संक्षिप्त रिकॉर्ड हो। प्रारंभिक सत्यापन के लिए, रंगों और इमेजिंग कार्यों के अपेक्षित व्यवहार की पुष्टि करने के लिए एक इमेज सैंपल का त्वरित विज़ुअलाइज़ेशन चलाएं, और सुनिश्चित करें कि हर इमेज पथ दस्तावेजित पाइपलाइन से संरेखित हो।

एक छोटा फीडफॉरवर्ड नेटवर्क लागू करें: फॉरवर्ड पास, सक्रियण, और हानि फंक्शन

फॉरवर्ड पास और हानि को मान्य करने के लिए दो-लेयर छोटे नेटवर्क से शुरू करें। यहां कार्य फॉरवर्ड पास, सक्रियण, और एक हानि फंक्शन लागू करना है, और फिर ठोस परिणाम मिलने पर विस्तार करें। नेटवर्क इनपुट फीचर्स से सीधे भविष्यवाणियां उत्पन्न करता है, इसलिए सक्रियणों को विज़ुअलाइज़ करने के लिए छोटा रंग पैलेट उपयोग करें और शोर से बचने के लिए रोशनी को सरल रखें। यह दृष्टिकोण डिबगिंग के लिए एक शांत वातावरण बनाता है, जो आपको दिखाने में मदद करता है कि हर गणना परिणामी कार्य से कैसे मैप होती है।

फॉरवर्ड पास को इस तरह योजना बनाएं: x R^n में है, W1 R^{h×n} में, b1 R^h में, a1 = σ(W1 x + b1)। फिर W2 R^{m×h} में, b2 R^m में, z2 = W2 a1 + b2, a2 = σ(z2)। हानि a2 को लक्ष्य y R^m में MSE का उपयोग करके तुलना करती है: L = 0.5 ||a2 − y||²। वर्गीकरण के लिए, क्रॉस-एंट्रॉपी पर स्विच करें। प्रत्येक चरण को सत्यापित करने के लिए सीधे गणनाओं का उपयोग करें, और फैंसी ट्रिक्स के बजाय प्रवाह पर ध्यान केंद्रित रखें। लक्ष्य आज उपलब्ध सबसे आवश्यक विवरणों के साथ एक स्पष्ट, व्यावहारिक समाधान है।

कोर समीकरण और एक छोटा संख्यात्मक उदाहरण

उदाहरण: n = 2, h = 2, m = 1; x = [0.5, −0.2], W1 = [[0.5, −0.3], [0.2, 0.7]], b1 = [0, 0], W2 = [0.4, −0.6], b2 = [0]। z1 = W1 x + b1 = [0.31, −0.04], a1 = ReLU(z1) = [0.31, 0]। z2 = W2 a1 + b2 = 0.124, a2 = sigmoid(0.124) ≈ 0.532। लक्ष्य y = 0.60; L ≈ 0.5 × (0.532 − 0.60)² ≈ 0.0023। यह एकल उदाहरण दिखाता है कि फॉरवर्ड पास एक ठोस परिणाम में कैसे अनुवाद होता है, जिसमें प्रत्येक लेयर पर योगदानों को ट्रैक करने में टोकन मैपिंग मदद करता है। ग्राफ के रंग से चिह्नित किया जा सकता है कि कौन से वजन सक्रिय होते हैं और प्रत्येक चरण पर मान कैसे बदलते हैं।

एक सरल प्रॉम्प्ट सूत्र व्युत्पन्न करें: संरचना, चर, और नियम

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

संरचना

लक्ष्य: इच्छित परिणाम बताने वाला एक वाक्य। विषय: मुख्य वस्तु या चरित्र। संदर्भ: सेटिंग, लाइटिंग, और मूड। बाधाएं: शैली, पहलू अनुपात, रिज़ॉल्यूशन, और संदर्भ जैसे मिडजर्नी या प्रॉम्प्ट। उदाहरण: लक्ष्य: ग्राहकों के लिए एक मस्तिष्क अवधारणा छवि उत्पन्न करें; विषय: एक मानव जैसा जासूस; संदर्भ: रात में नियॉन शहर सिनेमाई लाइटिंग के साथ; बाधाएं: 16:9, 8k, फोटोरियलिस्टिक, होसोडा की शैली में, नॉन-फिक्शन विज़ुअल्स के लिए उपयुक्त, मिडजर्नी और आर्टस्टेशन पर प्रॉम्प्ट तैनाती के लिए तैयार।

चर और नियम

आप नियंत्रित चरों में थीम, मूड, लाइटिंग, रंग पैलेट, संरचना, कैमरा कोण, और रिज़ॉल्यूशन जैसे तकनीकी शामिल हैं। नियम: प्रत्येक फील्ड को संक्षिप्त रखें (1–2 वाक्यांश), प्रॉम्प्ट के साथ समाप्त करें, और मिडजर्नी और आर्टस्टेशन के लिए आवश्यक संदर्भ शामिल करें। सुनिश्चित करें कि आउटपुट लक्षित ग्राहकों से मेल खाता हो। यदि आप एक अलग शैली चाहते हैं, तो एक अलग सेट आज़माएं और आउटपुट की तुलना करें; ऐसा दृष्टिकोण नॉन-फिक्शन कार्यों के लिए अनुकूलन में मदद करता है। कार्यप्रवाह को मानकीकृत करने के लिए अंतिम प्रॉम्प्ट को आवश्यक स्थान पर रखें; यह मस्तिष्क वाइब इरादे और पर्यावरण के बारे में विशिष्ट विवरण जोड़ने से आता है।

सूत्र को प्रॉम्प्ट टेम्पलेट्स में बदलें: सिंटैक्स, उदाहरण, और बाधाएं

बेस सूत्र को लॉक करें और इसे टेम्पलेट्स के परिवार में बदलें। यह न्यूरल नेटवर्क के साथ काम करने वाले लोगों को सदस्यता कार्यप्रवाहों में सुसंगत रहने में मदद करता है और प्रयास की डुप्लिकेशन के बिना प्रॉम्प्ट्स को स्केल करता है। एक स्पष्ट असेंबल नियम का उपयोग करें: विचार + शैली + पैलेट + माध्यम + बाधाएं। फील्ड्स को प्लेसहोल्डर्स के रूप में व्यवहार करें: {विचार}, {शैली}, {पैलेट}, {माध्यम}, {बाधाएं}। भाषा को तेज, संक्षिप्त, और निश्चित विवरण स्तर पर दोहराने योग्य रखें ताकि आउटपुट ड्रिफ्ट से बचा जा सके। यदि आप कवरेज विस्तारित करना चाहते हैं, तो एक कोर टेम्पलेट को विस्तारित बाधाओं के साथ पूरक करें जबकि सामान्य संरचना बनाए रखें।

• सिंटैक्स सिद्धांत
  1. बेस सूत्र ब्लूप्रिंट: विचार + शैली + पैलेट + माध्यम + बाधाएं।
  2. प्लेसहोल्डर्स पत्रकार जैसी स्पष्टता से मैप होते हैं: {विचार} अवधारणा का वर्णन करता है, {शैली} कलात्मक दृष्टिकोण का नाम देता है, {पैलेट} रंग मार्गदर्शन सेट करता है, {माध्यम} आउटपुट प्रकार का संकेत देता है, {बाधाएं} लंबाई, टोन, और प्रारूप को नियंत्रित करता है।
  3. कुछ प्रॉम्प्ट्स को सदस्यता टियर के तहत विलय करने के लिए एकल सामान्य फ्रेमवर्क बनाए रखें बिना स्थिरता खोए।
• तैनात करने के लिए टेम्पलेट्स
  1. कोर प्रॉम्प्ट (केवल टेक्स्ट): "दिए गए बाधाओं को पूरा करते हुए, न्यूनतम पैलेट के साथ चुनी गई शैली में एक विचार बनाएं।"
  2. विस्तारित प्रॉम्प्ट (टेक्स्ट-टू-इमेज फोकस): "{शैली} में {विचार} की एक आश्चर्यजनक रूप से विस्तृत छवि उत्पन्न करें, नियॉन पैलेट का उपयोग करते हुए, {पैलेट}, तेज रेखाओं और न्यूनतम संरचना के साथ, 16:9 पहलू में। बाधाएं: {बाधाएं}।"
  3. वन-क्लिक प्रॉम्प्ट (तटस्थ टोन): "{पैलेट} टोन के साथ {शैली} में {विचार} का वर्णन करें। आउटपुट लंबाई: {बाधाएं}।"
• माध्यम-विशिष्ट संकेत
  1. टेक्स्ट-इमेज कार्यों के लिए, माध्यम संकेत जोड़ें: "दृश्य, उच्च-कॉन्ट्रास्ट, पोस्टर-जैसे" तेज परिणामों को धकेलने के लिए।
  2. न्यूरल नेटवर्क आउटपुट के लिए, विवरण स्तर और संदर्भ निर्दिष्ट करें: "एक संक्षिप्त पैराग्राफ" या "मल्टी-पैनल लेआउट" पीढ़ी को निर्देशित करने के लिए।
  3. न्यूनतम शैली और बैंक्सी प्रभाव को वाइब नोट के रूप में संदर्भित करें: मूड स्पष्ट करने के लिए पैरेंथेटिकल संकेत में बैंक्सी शामिल करें।

• उदाहरण

  1. उदाहरण 1 – टेक्स्ट-इमेज:

     प्रॉम्प्ट: {विचार} की एक आश्चर्यजनक रूप से विस्तृत छवि उत्पन्न करें पोस्टइंप्रेशनिज्म शैली में, नियॉन उच्चारणों और न्यूनतम संरचना के साथ, तेज किनारों, और बैंक्सी जैसी धार (बैंक्सी)। 16:9 अनुपात का उपयोग करें; चौड़ाई 1920, ऊंचाई 1080। बाधाएं: {बाधाएं}।

  2. उदाहरण 2 – न्यूरल नेटवर्क वर्णन:

     प्रॉम्प्ट: {शैली} में {विचार} का एक पैराग्राफ वर्णन प्रदान करें {पैलेट} टोन के साथ। इसे संक्षिप्त रखें (120 शब्दों तक)। लक्ष्य डाउनस्ट्रीम कार्यों के लिए स्पष्ट अवधारणा हस्तांतरण है। बाधाएं: {बाधाएं}।

  3. उदाहरण 3 – सामान्य योजना:

     प्रॉम्प्ट: {पैलेट} पैलेट के साथ {शैली} में वर्णित {विचार}, सदस्यता उपयोग के लिए अनुकूलित। आउटपुट: {बाधाएं}। एक छोटा संदर्भ नोट शामिल करें: इच्छित दर्शकों (लोगों) के बारे में कुछ और जहां यह लागू होता है (स्थान)।

• बाधाएं और गार्डरेल
  1. ड्रिफ्ट से बचने के लिए प्रति टेम्पलेट परिवार एक मुख्य प्रारूप रखें।
  2. टेक्स्ट आउटपुट के लिए लंबाई सीमित करें (एक-दो वाक्यों से अधिक नहीं या लगभग 120 शब्द)।
  3. इमेज के लिए, रिज़ॉल्यूशन को 1920x1080 या लंबी धार पर 2048px तक कैप करें; पहलू अनुपात स्पष्ट रूप से निर्दिष्ट करें (उदाहरण के लिए, 16:9)।
  4. टोन और शैली लागू करें: तेज, न्यूनतम, और दृश्य-चालित; विस्तृत कथा से बचें।
  5. कुछ लचीलापन अनुमति दें: कभी-कभी पैलेट या मूड में छोटे विचलन स्वीकार्य हैं यदि कोर विचार बरकरार रहता है।

त्वरित प्रयोग चलाएं: डेटा, मेट्रिक्स, और पुनरावृत्ति ट्वीक्स

सिफारिश: सरल 2-लेयर नेटवर्क का उपयोग करके 1,000-सैंपल बेसलाइन से शुरू करें। 70–72% सटीकता, वैलिडेशन हानि 0.9 से कम, और CPU पर प्रति आइटम 60 ms से कम लेटेंसी लक्ष्य रखें। अनुरोधों को लॉग करें और उत्तरों का इंडेक्स बनाएं ताकि इनपुट को आउटपुट से मैप कर सकें; यह कार्य की शारीरिक रचना को स्पष्ट रूप से प्रकट करता है और कौन सी विशेषता त्रुटियों को चलाती है। पहले रनों का नाम ड्रैगन-01 और जेनेसिस-01 रखें तुलना के लिए, प्रत्येक विविधता को छोटा रखें ताकि आप ठोस परिवर्तनों को नीचे देख सकें। मेरी टीम के साथ परिणाम साझा करें ताकि अगला परीक्षण क्या हो, इस पर संरेखित हो सकें। परिणाम स्पष्ट रूप से दिखाते हैं कि कितने मामलों और कौन सी फीचर्स मेट्रिक्स को स्थानांतरित करती हैं, किसी पूर्वाग्रह के बिना।

बेसलाइन सेटअप

डेटा: 1,000 ट्रेनिंग सैंपल, 200 वैलिडेशन; यदि आप परिधान के साथ काम कर रहे हैं, तो कपड़ों (कपड़ों) का सबसेट और एक सरल इमेज 28x28 शामिल करें ताकि कम्प्यूट हल्का रहे। मॉडल: 128/64 यूनिट्स के साथ 2-लेयर MLP; सक्रियण ReLU; ऑप्टिमाइज़र Adam; लर्निंग रेट 0.001; बैच 32; एपॉच 3। मेट्रिक्स: सटीकता, प्रेसिजन, रिकॉल, F1, वैलिडेशन पर क्रॉस-एंट्रॉपी हानि; इंजन पर मापी गई लेटेंसी; मिलीसेकंड में प्रति बैच समय रिपोर्ट करें। फीचर प्रभाव को समझने के लिए, एक कॉम्पैक्ट द्रव्यमान फीचर्स रखें और देखें कि फीचर्स को गिराने या जोड़ने पर सटीकता कैसे शिफ्ट होती है, ताकि कार्य के महत्वपूर्ण संकेत देख सकें।

तेज प्रयोग योजना

तीन त्वरित ट्वीक्स चलाएं और तुलना करें: 1) लर्निंग रेट 0.0005, 0.001, 0.005; 2) बैच साइज 16, 64, 128; 3) सरल वृद्धि या सामान्यीकरण (के साथ या बिना)। प्रत्येक रन के लिए, समान मेट्रिक्स प्लस समस्याग्रस्त अनुरोधों की संख्या लॉग करें और क्या इंडेक्स उत्तरों में सुधार के लिए अपडेट होते हैं। हर ट्रायल के बाद, देखें कि कौन से वर्ग लाभ देखते हैं और वजन द्रव्यमान को तदनुसार समायोजित करें। स्पष्ट रूप से रनों का नाम दें (जैसे, ड्रैगन-02, जेनेसिस-02) और उन परिणामों का उपयोग प्रॉम्प्ट्स और डेटा स्लाइस को परिष्कृत करने के लिए पहली प्रकार की कार्यों की थीम के लिए। इन ट्वीक्स को सीधे ट्रेनिंग चक्र में डालें, ताकि परिणाम टीम के काम और प्रश्नों के विज़ुअलाइज़ेशन के लिए पुनरुत्पादनीय और समझने योग्य हों।

प्रॉम्प्ट्स और ट्रेनिंग लूप्स डिबग करें: सामान्य गड्ढे और सुधार

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

पीढ़ी में, असमान सेटिंग्स असंगत गुणवत्ता का कारण बनती हैं: पुनरावृत्तियों के बीच तापमान या टॉप-पी में भिन्नता, और आप मूल्यांकन मेट्रिक्स को भ्रमित करेंगे। एक डिफ़ॉल्ट और निश्चित पैरामीटर सेट करें (उदाहरण के लिए, तापमान = 0.2, टॉप-पी = 0.9) और एक समय में एक परिवर्तन टेस्ट करें; आकार और परिणाम पर प्रभाव की निगरानी करें; बाद में क्या हुआ ट्रेस करने के लिए रिकॉर्ड में हर परिवर्तन दस्तावेज करें।

सहयोगी कार्यप्रवाहों के लिए, आउटपुट को निदेशक और टीम के लिए उपयुक्त संक्षिप्त सारांशों के रूप में संरचित करें। प्रॉम्प्ट्स का संक्षिप्त विश्लेषण, संख्यात्मक गुणवत्ता स्कोर, टोकन उपयोग, और लेटेंसी शामिल करें; आप पिछले रनों को संलग्न कर सकते हैं प्रगति दिखाने और सुधार कहां समझ में आते हैं, मोरिमोटो, जेमिनी, और अन्य इंजन प्रतिभागियों को अगले चरणों पर संरेखित करने में मदद करते हैं। आगे, एक पुनरावृत्ति-तैयार बैकलॉग बनाए रखें: मुद्दे प्रति एक रिकॉर्ड, एक स्पष्ट परिकल्पना, और सभी भविष्य के डेटा और प्रॉम्प्ट्स पर लागू करने के लिए एक ठोस, निर्माण योग्य सुधार।