हर AI इंजीनियर को पता होने चाहिए ये 20 लूप डिज़ाइन पैटर्न

अधिकांश AI इंजीनियर जानते हैं कि एजेंट कैसे बनाया जाता है।

बहुत कम लोग जानते हैं कि ऐसा सिस्टम कैसे बनाया जाए जो पहले प्रयास के बाद बेहतर होता जाए।

यह अंतर छह अंकों का है।

यह रहा अंतर:

एजेंट एक कार्यकर्ता है।

लूप वह चीज़ है जो कार्यकर्ता को बेहतर बनाती है।

आज प्रोडक्शन में सबसे सक्षम AI सिस्टम सिंगल मॉडल कॉल नहीं हैं।

वे लूप हैं।

जनरेट करें → मूल्यांकन करें → सीखें → सुधार करें।

बार-बार।

जब तक आउटपुट वास्तव में अच्छा न हो जाए।

यहां 20 लूप डिज़ाइन पैटर्न हैं जो प्रोडक्शन AI सिस्टम में बार-बार दिखाई देते हैं।

इसे सेव करें। आप इनके साथ बिल्ड करेंगे।

एजेंट बनाम लूप

पुराना तरीका: प्रॉम्प्ट → रिस्पॉन्स → हो गया।

नया तरीका: जनरेट करें → आलोचना करें → फिर से लिखें → स्कोर करें → पुनः प्रयास करें → याद रखें → सुधार करें।

एक फैक्ट्री वर्कर है जो काम एक बार करता है।

दूसरा फैक्ट्री वर्कर है जो हर गलती का अध्ययन करता है, प्लेबुक को फिर से लिखता है, और हर शिफ्ट में 3% बेहतर होता जाता है।

इस समय प्रोडक्शन AI शिप करने वाली टीमें बेहतर प्रॉम्प्ट नहीं लिख रही हैं।

वे बेहतर लूप बना रही हैं।

श्रेणी 1 — गुणवत्ता सुधार लूप (सिस्टम से बाहर निकलने से पहले आउटपुट को बेहतर बनाएं)

1. जनरेट करें → आलोचना करें → फिर से लिखें

AI इंजीनियरिंग में सबसे महत्वपूर्ण लूप।

आउटपुट जनरेट करें। आलोचक इसकी समीक्षा करता है। जनरेटर फीडबैक के आधार पर फिर से लिखता है। गुणवत्ता सीमा पूरी होने तक दोहराएं।

एक मॉडल नहीं। दो भूमिकाएँ। एक पाइपलाइन।

1[जनरेटर] → ड्राफ्ट
2[आलोचक] → "पैराग्राफ 3 अस्पष्ट है। सबूत गायब है। लहजा सही नहीं है।"
3[जनरेटर] → आलोचना के आधार पर फिर से लिखें
4[आलोचक] → "बेहतर है। लेकिन निष्कर्ष अभी भी कमजोर है।"
5[जनरेटर] → अंतिम पुनर्लेखन

इसके लिए उपयोग किया जाता है: लेखन, कोड समीक्षा, रिपोर्ट, रणनीति दस्तावेज़, बिक्री ईमेल।

अंतर्दृष्टि: जो मॉडल जनरेट करता है वह अपने स्वयं के आउटपुट का सबसे अच्छा न्यायाधीश नहीं है।

एक अलग आलोचक हर बार वह खोज लेता है जो जनरेटर से छूट गया था।

2. स्कोर-एंड-रीट्राई लूप

जनरेट करें। स्कोर करें। सीमा से कम होने पर पुनः प्रयास करें।

सरल। शक्तिशाली। कम उपयोग किया गया।

स्कोर = मूल्यांकन(आउटपुट)

1स्कोर = मूल्यांकन(आउटपुट)
2
3जबकि स्कोर < सीमा:
4    आउटपुट = जनरेट(प्रॉम्प्ट)
5    स्कोर = मूल्यांकन(आउटपुट)
6    प्रयास += 1
7    यदि प्रयास > अधिकतम_पुनःप्रयास:
8        वापसी अब_तक_का_सर्वश्रेष्ठ

सबसे अच्छा तब काम करता है जब गुणवत्ता मापने योग्य हो — निष्कर्षण सटीकता, प्रारूप अनुपालन, तथ्यात्मक शुद्धता, लीड स्कोरिंग।

जनरेटर को नहीं पता कि उसे ग्रेड दिया जा रहा है।

मूल्यांकनकर्ता को पता है।

यह अलगाव ही पैटर्न है।

3. मल्टी-क्रिटिक लूप

एक आलोचक की अंधी धब्बे होते हैं।

चार का उपयोग करें।

→ शुद्धता आलोचक: क्या यह तथ्यात्मक रूप से सटीक है?

→ शैली आलोचक: क्या यह स्पष्ट और अच्छी तरह से लिखा गया है?

→ सुरक्षा आलोचक: क्या यह उपयुक्त और सुरक्षित है?

→ डोमेन आलोचक: क्या यह विशेषज्ञ मानकों को पूरा करता है?

प्रत्येक स्वतंत्र रूप से मूल्यांकन करता है।

अंतिम आउटपुट को बाहर निकलने से पहले सभी चारों को संतुष्ट करना होगा।

इसमें उपयोग किया जाता है: मेडिकल AI, कानूनी दस्तावेज़ समीक्षा, वित्तीय विश्लेषण, विनियमित सामग्री।

4. प्रतिकूल आलोचना लूप

आलोचक का एकमात्र काम उत्तर को तोड़ना है।

इसे सुधारना नहीं। इसे तोड़ना।

प्रतिकूल आलोचक द्वारा पूछे जाने वाले प्रश्न:

→ यहाँ कौन सी धारणाएँ विफल होती हैं? → कौन से सबूत गायब हैं? → एक संशयवादी क्या कहेगा? → यह आत्मविश्वास से कहाँ गलत है?

फिर जनरेटर बचाव करता है या फिर से लिखता है।

सबसे अच्छा उत्तर हमले से बच जाता है।

इसके लिए उपयोग किया जाता है: शोध संश्लेषण, निवेश थीसिस समीक्षा, रणनीतिक योजना, जोखिम विश्लेषण।

5. जज एन्सेम्बल लूप

एक जज शोरगुल वाले स्कोर देता है।

पाँच जज शोर को औसत कर देते हैं।

एक ही आउटपुट को कई मूल्यांकनकर्ताओं के माध्यम से चलाएँ।

स्कोर एकत्रित करें।

केवल उच्च सहमति वाले आउटपुट ही आगे बढ़ते हैं।

इसका उपयोग तब किया जाता है जब: एकल-मॉडल मूल्यांकन अविश्वसनीय हो, दांव ऊंचे हों, किनारे के मामले मायने रखते हों।

श्रेणी 2 — मेमोरी लूप (जो हुआ उससे सीखें ताकि अगली बार होशियार हो सकें)

6. रिफ्लेक्सियन लूप

सबसे महत्वपूर्ण स्व-सुधार पैटर्न जो मौजूद है।

एजेंट विफल रहता है। एजेंट विश्लेषण करता है कि वह क्यों विफल रहा। एजेंट सबक संग्रहीत करता है। एजेंट उस सबक के संदर्भ में पुनः प्रयास करता है।

प्रत्येक पुनरावृत्ति: पिछली बार से अधिक होशियार।

1प्रयास 1: विफल
2चिंतन: "मैंने X मान लिया लेकिन X गलत था। अगली बार पहले X सत्यापित करें।"
3प्रयास 2: सबक शामिल करता है → आंशिक सफलता
4चिंतन: "बेहतर है। लेकिन मैं Y छोड़ गया। Y जांच जोड़ें।"
5प्रयास 3: सफल

एक ऐसी प्रणाली के बीच का अंतर जो एक बार विफल होती है और एक ऐसी प्रणाली जो केवल एक बार विफल होती है।

7. मेमोरी अपडेट लूप

प्रत्येक कार्य के बाद, तीन चीज़ें संग्रहीत करें:

→ क्या निर्णय लिया गया → परिणाम क्या था → क्या अलग किया जाता

भविष्य के रन इस ज्ञान को प्राप्त करते हैं।

महीने 6 में सिस्टम महीने 1 के सिस्टम जैसा नहीं है।

इसने अपने स्वयं के इतिहास के 6 महीने पढ़ लिए हैं।

8. एरर लाइब्रेरी लूप

हर विफलता को संग्रहीत करें।

गलत उत्तर। खराब आउटपुट। असफल निष्पादन। किनारे का मामला।

किसी नए कार्य पर कार्य करने से पहले:

पहले त्रुटि लाइब्रेरी खोजें।

यदि समान विफलता मौजूद है → शुरू करने से पहले ही ज्ञात सुधार लागू करें।

सिस्टम एक ही गलती दो बार करना बंद कर देता है।

प्रोडक्शन AI में सबसे कम उपयोग किया जाने वाला पैटर्न।

9. सफलता पैटर्न लूप

अधिकांश इंजीनियर केवल विफलताओं को संग्रहीत करते हैं।

सफलताओं को भी संग्रहीत करें।

जब कोई कार्य अच्छी तरह से होता है:

→ दृष्टिकोण सहेजें → संदर्भ सहेजें → जो चीज़ इसे काम करती है उसे सहेजें

समान कार्यों का सामना करने पर सफल पैटर्न प्राप्त करें।

जीत से सीखें। सिर्फ गलतियों से नहीं।

10. मेमोरी कम्प्रेशन लूप

मेमोरी हमेशा बढ़ती रहती है।

असीमित मेमोरी अनुपयोगी मेमोरी है।

N आइटम जमा होने के बाद:

उन्हें संपीड़ित करें।

कई विशिष्ट यादें → कम उच्च-स्तरीय अमूर्तताएँ।

1संपीड़न से पहले:
2"कार्य A में X के कारण विफल रहा"
3"कार्य B में X के कारण विफल रहा"
4"कार्य C में X के कारण विफल रहा"
5
6संपीड़न के बाद:
7"पैटर्न: X विफलताओं का कारण बनता है। हमेशा पहले X जांचें।"

संदर्भ प्रबंधनीय रहता है। पैटर्न सुलभ रहते हैं। सिस्टम तेज़ रहता है।

श्रेणी 3 — योजना लूप (जब वास्तविकता बदलती है तो योजना को अनुकूलित करें)

11. योजना बनाएं → निष्पादित करें → पुनः योजना बनाएं

AI एजेंट डिज़ाइन में सबसे आम गलती:

योजना को निश्चित मानना।

योजनाएँ वास्तविकता के संपर्क में आने पर टूट जाती हैं।

पैटर्न:

योजना बनाएं → चरण निष्पादित करें → परिणाम देखें → योजना अपडेट करें → जारी रखें

वाटरफॉल नहीं।

एक सर्पिल।

प्रत्येक चक्कर दृष्टिकोण को कसता है।

इसका उपयोग तब किया जाता है जब: वातावरण बदलता है, कार्यों में निर्भरताएँ होती हैं, लंबी अवधि के लक्ष्य हों।

12. डायनामिक वर्कफ़्लो लूप

अधिकांश पाइपलाइनें निश्चित होती हैं।

चरण 1 → चरण 2 → चरण 3। हमेशा।

डायनामिक वर्कफ़्लो परिणामों के आधार पर बदलते हैं।

यदि आउटपुट A → शाखा X चलाएँ यदि आउटपुट B → शाखा Y चलाएँ यदि आउटपुट C → चरण 5 पर जाएँ

पाइपलाइन रनटाइम पर अपना स्वयं का आकार तय करती है।

इसमें उपयोग किया जाता है: मल्टी-डॉक्यूमेंट रिसर्च, कस्टमर सपोर्ट रूटिंग, एडेप्टिव कंटेंट पाइपलाइन।

13. लक्ष्य अपघटन लूप

बड़ा लक्ष्य प्रवेश करता है।

सिस्टम इसे उप-लक्ष्यों में तोड़ता है।

प्रत्येक उप-लक्ष्य कार्यों में टूटता है।

प्रत्येक कार्य चरणों में टूटता है।

तब तक विघटित करें जब तक प्रत्येक इकाई एक कॉल में निष्पादित करने के लिए पर्याप्त छोटी न हो।

1लक्ष्य: "एक व्यापक प्रतिस्पर्धी विश्लेषण लिखें"
2↓
3उप-लक्ष्य 1: "शीर्ष 5 प्रतिस्पर्धियों की पहचान करें"
4उप-लक्ष्य 2: "प्रत्येक प्रतिस्पर्धी के उत्पाद का विश्लेषण करें"
5उप-लक्ष्य 3: "मूल्य निर्धारण मॉडल की तुलना करें"
6उप-लक्ष्य 4: "अंतराल की पहचान करें"
7↓
8प्रत्येक उप-लक्ष्य → कार्य → व्यक्तिगत मॉडल कॉल

लूप तब तक विघटित करता रहता है जब तक सिस्टम कार्य नहीं कर सकता।

14. प्रगति मूल्यांकन लूप

प्रत्येक N चरणों के बाद: रुकें और पूछें।

"क्या हम वास्तव में लक्ष्य के करीब पहुँच रहे हैं?"

यदि हाँ: वर्तमान रणनीति जारी रखें। यदि नहीं: रणनीति, उपकरण या योजना बदलें।

सिस्टम अपनी स्वयं की प्रगति की निगरानी करता है।

सिर्फ आँख बंद करके निष्पादित नहीं करता।

इसमें उपयोग किया जाता है: लंबे समय तक चलने वाले शोध एजेंट, बहु-दिवसीय स्वायत्त कार्य, डिबगिंग एजेंट।

15. बाधा संतुष्टि लूप

तब तक चलते रहें जब तक सभी बाधाएँ पूरी न हो जाएँ।

1जबकि सभी_बाधाएँ_संतुष्ट_नहीं(आउटपुट):
2    आउटपुट = सुधारें(आउटपुट, असंतुष्ट_बाधाएँ)
3
4बाधाएँ = [
5    बजट_सीमा_के_अंतर्गत,
6    गुणवत्ता_सीमा_से_ऊपर,
7    विलंबता_200ms_से_कम,
8    लहजा_ब्रांड_से_मेल_खाता,
9    कोई_भ्रम_नहीं
10]

प्रोडक्शन सिस्टम में बहुत आम है।

आउटपुट तब तक तैयार नहीं होता जब तक हर व्यावसायिक नियम पास नहीं हो जाता।

श्रेणी 4 — अन्वेषण लूप (कई रास्ते आज़माकर सबसे अच्छा उत्तर खोजें)

16. ब्रांच-एंड-एक्सप्लोर लूप

एक रास्ते पर प्रतिबद्ध न हों।

एक साथ कई का अन्वेषण करें।

1रास्ते = [
2    जनरेट(दृष्टिकोण="रूढ़िवादी"),
3    जनरेट(दृष्टिकोण="आक्रामक"),
4    जनरेट(दृष्टिकोण="रचनात्मक")
5]
6
7स्कोर = [मूल्यांकन(p) के लिए p in रास्ते]
8सर्वश्रेष्ठ = रास्ते[स्कोर.इंडेक्स(अधिकतम(स्कोर))]

परिणामों की तुलना करें। सबसे अच्छी शाखा चुनें। बाकी को त्याग दें।

इसके लिए उपयोग किया जाता है: सामग्री विविधताएँ, आर्किटेक्चर निर्णय, कई परिकल्पनाओं को डीबग करना, A/B जनरेशन।

17. ट्री सर्च लूप

ब्रांच-एंड-एक्सप्लोर एक स्तर गहरा जाता है।

ट्री सर्च आवश्यकतानुसार गहरा जाता है।

सबसे आशाजनक नोड्स का विस्तार करें। सबसे कमजोर नोड्स को काटें। समाधान मिलने तक अन्वेषण जारी रखें।

1जड़ → [A, B, C]
2A → [A1, A2]   # A आशाजनक दिखता है, इसका विस्तार करें
3B → काटें      # B कमजोर है, यहाँ रुकें
4A1 → [A1a, A1b]
5A1a → समाधान ✓

इसके लिए उपयोग किया जाता है: जटिल तर्क श्रृंखलाएँ, बहु-चरणीय योजना, कोड डिबगिंग, शोध संश्लेषण।

कम्प्यूटेशनल रूप से महंगा है लेकिन ऐसे समाधान ढूंढता है जो सिंगल-पास कॉल नहीं ढूंढ सकते।

18. डिबेट लूप

दो एजेंट। एक विषय। विपरीत स्थितियाँ।

एजेंट A उत्तर के पक्ष में तर्क देता है। एजेंट B इसके विरुद्ध तर्क देता है।

प्रत्येक दौर धारणाओं को चुनौती देता है, सबूत की मांग करता है, कमजोर तर्क को उजागर करता है।

अंतिम उत्तर असहमति के माध्यम से उभरता है।

सहमति के माध्यम से नहीं।

प्रतिकूल दबाव वह खोज लेता है जो आत्मविश्वासी एकल-एजेंट उत्तरों से छूट जाता है।

इसके लिए उपयोग किया जाता है: निवेश निर्णय, रणनीतिक योजना, जोखिम मूल्यांकन, शोध आलोचना।

श्रेणी 5 — सिस्टम ऑप्टिमाइज़ेशन लूप (लूप लूप को बेहतर बनाता है)

19. प्रॉम्प्ट ऑप्टिमाइज़ेशन लूप

अधिकांश इंजीनियर एक बार प्रॉम्प्ट लिखते हैं और फिर कभी उसे नहीं छूते।

प्रॉम्प्ट ऑप्टिमाइज़ेशन लूप इसे बदल देते हैं।

सिस्टम:

→ एक टेस्ट सेट पर प्रॉम्प्ट चलाता है

→ हर आउटपुट को स्कोर करता है

→ पहचानता है कि प्रॉम्प्ट कहाँ विफल होता है

→ उन विफलताओं को ठीक करने के लिए प्रॉम्प्ट को फिर से लिखता है → पुनः चलाता है और पुनः स्कोर करता है

प्रॉम्प्ट स्वचालित रूप से बेहतर होता जाता है।

बिना किसी मानव के इसे छुए।

1वर्तमान_प्रॉम्प्ट = "इस दस्तावेज़ का सारांश दें।"
2
3पुनरावृत्ति के लिए in range(अधिकतम_पुनरावृत्तियाँ):
4    आउटपुट = [चलाएँ(वर्तमान_प्रॉम्प्ट, दस्तावेज़) के लिए दस्तावेज़ in परीक्षण_सेट]
5    स्कोर = [मूल्यांकन(o) के लिए o in आउटपुट]
6    औसत_स्कोर = माध्य(स्कोर)
7
8    यदि औसत_स्कोर >= लक्ष्य:
9        तोड़ें
10
11    विफलताएँ = [o के लिए o, s in ज़िप(आउटपुट, स्कोर) यदि s < सीमा]
12    वर्तमान_प्रॉम्प्ट = सुधारें_प्रॉम्प्ट(वर्तमान_प्रॉम्प्ट, विफलताएँ)
13    # प्रॉम्प्ट स्वयं को फिर से लिखता है जहाँ वह विफल होता है

इसमें उपयोग किया जाता है: प्रोडक्शन पाइपलाइन, स्वचालित सामग्री सिस्टम, वर्गीकरण कार्य।

प्रोडक्शन AI में सबसे अच्छे प्रॉम्प्ट किसी मानव द्वारा नहीं लिखे गए थे।

वे विकसित हुए थे।

20. वर्कफ़्लो ऑप्टिमाइज़ेशन लूप

यह वह जगह है जहाँ यह दिलचस्प हो जाता है।

लूप लूप को बेहतर बनाता है।

सिस्टम अपने स्वयं के प्रदर्शन को मापता है:

→ विलंबता: प्रत्येक चरण में कितना समय लगता है?

→ लागत: प्रत्येक कॉल कितने टोकन का उपयोग करती है?

→ गुणवत्ता: प्रत्येक चरण पर आउटपुट स्कोर क्या है?

फिर यह अपने स्वयं के वर्कफ़्लो को संशोधित करता है।

बहुत धीमा? दो चरणों को समानांतर करें। बहुत महंगा? जहाँ गुणवत्ता बनी रहती है, वहाँ GPT-4 कॉल को छोटे मॉडल से बदलें। गुणवत्ता गिर रही है? अंतिम आउटपुट से पहले एक आलोचक जोड़ें।

1मीट्रिक = मापें_वर्कफ़्लो(आउटपुट, विलंबता, लागत)
2
3यदि मीट्रिक.विलंबता > लक्ष्य_विलंबता:
4    वर्कफ़्लो = समानांतर_करें(धीमे_चरण)
5
6यदि मीट्रिक.लागत > बजट:
7    वर्कफ़्लो = बदलें_सस्ते_मॉडल_से(उच्च_लागत_चरण)
8
9यदि मीट्रिक.गुणवत्ता < सीमा:
10    वर्कफ़्लो = जोड़ें_आलोचक_पहले(अंतिम_आउटपुट_चरण)

यह वह जगह है जहाँ वास्तव में स्व-सुधार करने वाली प्रणालियाँ शुरू होती हैं।

सिर्फ आउटपुट नहीं जो सुधरते हैं।

सिस्टम जो स्वयं को पुनः डिज़ाइन करते हैं।

सभी 20 पैटर्न के पीछे का पैटर्न

ऊपर दिया गया हर एक लूप एक संरचना साझा करता है:

कार्य करें → निरीक्षण करें → मूल्यांकन करें → समायोजित करें

यह पूरी रेसिपी है।

आउटपुट पहले प्रयास में कभी अंतिम नहीं होता।

आउटपुट एक शुरुआती बिंदु है।

लूप वह चीज़ है जो एक शुरुआती बिंदु को प्रोडक्शन-योग्य चीज़ में बदल देता है।

पूरा नक्शा

श्रेणी 1 — गुणवत्ता लूप (आउटपुट को बाहर निकलने से पहले बेहतर बनाएं)

→ 1. जनरेट करें → आलोचना करें → फिर से लिखें

→ 2. स्कोर-एंड-रीट्राई

→ 3. मल्टी-क्रिटिक

→ 4. प्रतिकूल आलोचना

→ 5. जज एन्सेम्बल

श्रेणी 2 — मेमोरी लूप (जो हुआ उससे सीखें)

→ 6. रिफ्लेक्सियन

→ 7. मेमोरी अपडेट

→ 8. एरर लाइब्रेरी

→ 9. सफलता पैटर्न

→ 10. मेमोरी कम्प्रेशन

श्रेणी 3 — योजना लूप (जब वास्तविकता बदलती है तो अनुकूलित करें)

→ 11. योजना बनाएं → निष्पादित करें → पुनः योजना बनाएं

→ 12. डायनामिक वर्कफ़्लो

→ 13. लक्ष्य अपघटन

→ 14. प्रगति मूल्यांकन

→ 15. बाधा संतुष्टि

श्रेणी 4 — अन्वेषण लूप (कई रास्ते आज़माकर सबसे अच्छा उत्तर खोजें)

→ 16. ब्रांच-एंड-एक्सप्लोर

→ 17. ट्री सर्च

→ 18. डिबेट

श्रेणी 5 — सिस्टम ऑप्टिमाइज़ेशन लूप (लूप लूप को बेहतर बनाता है)

→ 19. प्रॉम्प्ट ऑप्टिमाइज़ेशन

→ 20. वर्कफ़्लो ऑप्टिमाइज़ेशन

अधिकांश इंजीनियर सोचते हैं कि एजेंट ही भविष्य हैं।

एजेंट सिर्फ कार्यकर्ता हैं।

लूप वह चीज़ हैं जो कार्यकर्ताओं को बेहतर बनाती हैं।

AI में अभी जो सबसे बड़ा बदलाव हो रहा है, वह बेहतर मॉडल नहीं है।

यह इससे स्थानांतरित हो रहा है:

प्रॉम्प्ट → रिस्पॉन्स

से

जनरेट करें → मूल्यांकन करें → सीखें → सुधार करें

जो टीमें लूप डिज़ाइन में महारत हासिल करेंगी, वे बेहतर प्रॉम्प्ट नहीं बनाएंगी।

वे ऐसे सिस्टम बनाएंगी जो डिप्लॉयमेंट के बाद हर दिन बेहतर होते जाएंगे।

बिना किसी के उन्हें छुए।

यदि यह उपयोगी था:

→ इसे हर उस AI इंजीनियर के साथ साझा करने के लिए रिपोस्ट करें जिसे आप जानते हैं

→ इस तरह के और पैटर्न के लिए @sairahul1 को फॉलो करें

→ इसे बुकमार्क करें — एक लूप चुनें और इस सप्ताह इसे लागू करें

मैं AI, उत्पाद बनाने और ऐसे सिस्टम के बारे में लिखता हूँ जो आपके बिना काम करते हैं।