मुख्य सामग्री पर जाएँ

Andrej Karpathy के AutoResearch का मार्गदर्शक: AI एजेंट्स के साथ ML को स्वचालित करना

जानें कि Karpathy का AutoResearch एक ही GPU पर रात भर में 100+ ML प्रयोग कैसे चलाता है। तीन-फ़ाइल आर्किटेक्चर, रैचेट लूप, परिणाम, और सीमाएँ शामिल हैं।
· 11 मि॰ पढ़ें

AI के साथ खोजें

Andrej Karpathy का AutoResearch एक ओपन-सोर्स टूल है जो ML प्रयोगों को एक लूप में चलाता है और केवल उन्हीं बदलावों को रखता है जो मौजूदा सर्वश्रेष्ठ परिणाम को हरा दें। आप एक मार्कडाउन फ़ाइल में अनुसंधान दिशा लिखते हैं, एक AI कोडिंग एजेंट को रिपॉज़िटरी पर इंगित करते हैं, और हट जाते हैं। सुबह तक, आपके पास सत्यापित सुधारों का एक git इतिहास और एजेंट द्वारा आज़माई गई हर चीज़ का लॉग होता है।

7 मार्च, 2026 को जारी इस प्रोजेक्ट ने कुछ ही दिनों में 21,000+ GitHub सितारे बटोरे और Karpathy की घोषणा पर 8.6 मिलियन व्यूज़ मिले। यह लेख बताता है कि तीन-फ़ाइल आर्किटेक्चर कैसे काम करता है, रात भर के रन के दौरान रैचेट लूप क्या करता है, अब तक AutoResearch ने क्या परिणाम दिए हैं, और यह दृष्टिकोण किन सीमाओं से टकराता है।

AutoResearch क्या है?

AutoResearch एक ओपन-सोर्स Python टूल है जो एक AI एजेंट को बिना मानवीय हस्तक्षेप के एकल GPU पर ML प्रयोग चलाने देता है। यह प्रस्ताव-प्रशिक्षण-मूल्यांकन चक्रों के माध्यम से लूप करता है और केवल वे बदलाव रखता है जो वैलिडेशन लॉस में सुधार करें। प्रोजेक्ट MIT लाइसेंस के अंतर्गत आता है।

यह हाइपरपैरामीटर ट्यूनिंग नहीं है। Optuna या Ray Tune जैसे टूल एक पूर्व-परिभाषित पैरामीटर स्पेस में खोज करते हैं। AutoResearch एजेंट को मनचाही कोड मॉडिफाई करने की स्वतंत्रता देता है। सर्च स्पेस वही है जो LLM सोच सके—और यही इसे मौजूदा किसी भी टूल से अलग श्रेणी में रखता है।

AutoML और NAS (Neural Architecture Search) फ़्रेमवर्क संरचित अल्गोरिथ्मों के साथ आर्किटेक्चर या हाइपरपैरामीटर पर खोज करते हैं—सटीक, लेकिन अपने परिभाषित सर्च स्पेस तक सीमित।

AlphaEvolve (Google DeepMind) एल्गोरिथ्म डिस्कवरी के लिए एक evolutionary दृष्टिकोण और Gemini मॉडल्स का उपयोग करके इससे आगे जाता है, लेकिन यह क्लोज़्ड-सोर्स है और अधिकांश टीमों के लिए सुलभ नहीं। सामान्य-उद्देश्य कोडिंग एजेंट जैसे SWE-Agent, OpenHands, और Aider मनचाहा कोड लिख सकते हैं, लेकिन वे उस प्रयोग-मूल्यांकन-रखना/वापस लेना चक्र के लिए बने नहीं हैं जिसकी ML अनुसंधान को वास्तव में ज़रूरत होती है।

AutoResearch, सर्च स्पेस को गणितीय गारंटी के लिए सीमित करने के बजाय, अच्छे प्रयोग प्रस्तावित करने के लिए LLM के सामान्य ज्ञान पर दांव लगाता है।

AlphaEvolve, AutoML, NAS, और SWE-Agent के मुकाबले autoresearch की तुलना

वाइब कोडिंग से रिसर्च सलाहकार तक

Karpathy इसे इंजीनियरों के AI के साथ काम करने के स्वाभाविक विकास के रूप में पेश करते हैं। फरवरी 2026 में, उन्होंने "agentic engineering" शब्द गढ़ा: "99% समय आप सीधे कोड नहीं लिख रहे होते। आप उन एजेंट्स का संचालन कर रहे होते हैं जो लिखते हैं और आप पर्यवेक्षण करते हैं।" AutoResearch अगला कदम है। इंसान अब संचालन भी नहीं करता। वे एक मार्कडाउन फ़ाइल में अच्छा शोध कैसा दिखता है यह बताते हैं और हट जाते हैं।

विकास क्रम यह है: वाइब कोडिंग (इंसान प्रॉम्प्ट देता है, AI कोड लिखता है, इंसान समीक्षा करता है) से agentic engineering (इंसान रियल-टाइम में एजेंट्स का संचालन करता है) से पूर्णतः स्वतंत्र शोध (इंसान दिशा तय करता है, एजेंट अपने आप चलता है)। 

हर कदम पर इंसान की भूमिका लेखक से निर्देशक और, Karpathy के फ्रेमिंग में, शोध सलाहकार तक सिमटती जाती है।

वाइब कोडिंग से agentic engineering और फिर स्वतंत्र शोध तक का क्रम

एक फॉलो-अप पोस्ट में, उन्होंने अगला कदम बताया: "लक्ष्य एक अकेले PhD छात्र की नकल करना नहीं, बल्कि उनके एक शोध समुदाय की नकल करना है", जिसमें SETI@home-शैली के वितरित एजेंट सहयोग का संदर्भ है।

यह प्रणाली उस दृष्टि को तीन फ़ाइलों के माध्यम से मूर्त रूप देती है।

AutoResearch की तीन-फ़ाइल आर्किटेक्चर

AutoResearch की डिज़ाइन तीन फ़ाइलों के बीच एक अनुबंध पर टिकी है, जिनमें से हर एक के लिए सख्त नियम हैं कि उसे कौन छू सकता है।

prepare.py

prepare.py डेटा तैयारी और मूल्यांकन संभालती है। यह 8,192-टोकन शब्दावली वाला BPE (Byte Pair Encoding) टोकनाइज़र बनाती है, प्रशिक्षण कॉर्पस प्रोसेस करती है, और वैलिडेशन मेट्रिक परिभाषित करती है: val_bpb (वैलिडेशन बिट्स-पर-बाइट)। 

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

train.py

train.py एजेंट का सैंडबॉक्स है: 630 लाइनों में GPT मॉडल आर्किटेक्चर, Muon+AdamW ऑप्टिमाइज़र, और पूरा ट्रेनिंग लूप शामिल है। एजेंट यहाँ कुछ भी फिर से लिख सकता है (एक्टिवेशन फ़ंक्शंस बदलना, अटेंशन हेड्स को पुनर्गठित करना, लर्निंग-रेट शेड्यूल बदलना, वज़न इनिशियलाइज़ेशन मॉडिफाई करना) बशर्ते कि बदला हुआ कोड ट्रेन हो और एक val_bpb स्कोर उत्पन्न करे।

program.md

program.md सादा मार्कडाउन में लिखा जाता है और यही एकमात्र फ़ाइल है जिसे मानव लेखक छूता है। यह एजेंट को बताती है कि किन अनुसंधान दिशाओं का पीछा करना है, किनसे बचना है, और प्रयोगों का तरीका क्या होगा।

फ़ाइल भूमिकाएँ, स्वामित्व, और डेटा प्रवाह दिखाती तीन-फ़ाइल आर्किटेक्चर

program.md क्या नियंत्रित करता है

यह फ़ाइल अधिकांश लोगों की अपेक्षा से अधिक विशिष्ट है। यह बेसलाइन मीट्रिक्स को हार्डकोड करती है ताकि एजेंट जान सके कि किसे हराना है (val_bpb: 0.997900, पीक VRAM (वीडियो मेमोरी): 45 GB)। 

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

और इसमें वह निर्देश शामिल है जो पूरी प्रणाली को काम में लाता है: "कभी मत रुकें। एक बार जब प्रयोग लूप शुरू हो जाए, तो यह पूछने के लिए मत रुकें कि क्या आपको जारी रखना चाहिए।"

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

काम का बँटवारा साफ़ है। इंसान program.md के माध्यम से शोध दिशा तय करता है, एजेंट train.py को संशोधित करके अमल करता है, और prepare.py एक निष्पक्ष न्यायाधीश की तरह काम करती है जिसे कोई पक्ष नहीं छू सकता। यह अनुबंध लागू होने के साथ, एजेंट बिना रुके लगातार प्रयोग लूप चलाता है।

AutoResearch रैचेट लूप

AutoResearch का मूल एक ऐसा प्रयोग चक्र है जो बिना मानवीय इनपुट के चलता है। program.md में परिभाषित 9-चरण लूप के अनुसार एक इटरेशन ऐसे काम करता है:

  1. एजेंट मौजूदा शोध प्राथमिकताओं और बाधाओं को समझने के लिए program.md पढ़ता है।
  2. वह मौजूदा train.py और results.tsv में हाल के परिणामों की जाँच करता है।
  3. वह एक परिकल्पना प्रस्तावित करता है: आर्किटेक्चर में बदलाव, ऑप्टिमाइज़र समायोजन, या ट्रेनिंग में संशोधन।
  4. प्रस्तावित बदलाव लागू करने के लिए वह train.py को संशोधित करता है।
  5. वह बदलाव को एक git ब्रांच में कमिट करता है।
  6. वह ठीक 5 मिनट तक ट्रेनिंग चलाता है (फिक्स्ड वॉल-क्लॉक बजट)।
  7. यदि ट्रेनिंग क्रैश हो जाती है, तो वह विफलता लॉग करता है, कमिट रिवर्ट करता है, और फिर से कोशिश करता है।
  8. वह val_bpb का उपयोग करके परिणाम का मूल्यांकन करता है और उसे results.tsv में दर्ज करता है।
  9. यदि val_bpb में सुधार हुआ: कमिट बना रहता है। यदि नहीं: git reset HEAD~1 पिछले संस्करण पर लौट आता है।

इसके बाद यह फिर से चरण 1 से शुरू होता है।

प्रयोग चक्र दिखाता रैचेट लूप फ़्लोचार्ट

प्रत्येक प्रयोग को समान 5 मिनट का वॉल-क्लॉक बजट मिलता है, जिससे परिणाम सीधे तुलनीय होते हैं। जो बदलाव तेजी से ट्रेन करता है और जो कम लॉस तक अभिसरण करता है—दोनों का समान आधार पर मूल्यांकन होता है। 

5 मिनट प्रति प्रयोग की दर से, सिस्टम लगभग 12 प्रयोग प्रति घंटे चलाता है।

"रैचेट" नाम git इतिहास से आता है। हर सफल प्रयोग एक कमिट जोड़ता है; हर विफलता रिवर्ट हो जाती है। कोडबेस केवल आगे बढ़ सकता है, पीछे नहीं, और एक-एक करके सत्यापित सुधार जमा करता है।

रिसर्च मेमोरी के रूप में Git

संरचना में यह evolutionary अल्गोरिथ्म जैसा है, लेकिन AutoResearch जनसंख्या के बजाय एक ही वंशावली रखता है। उम्मीदवारों के बीच क्रॉसओवर और म्यूटेशन के स्थान पर, LLM ही म्यूटेशन ऑपरेटर (बदलाव प्रस्तावित करना) और चयन दबाव (पिछले परिणामों के आधार पर क्या आज़माना है चुनना) दोनों की भूमिका निभाता है। 

यह अपने ही git इतिहास और results.tsv पढ़ता है ताकि जो भी आशाजनक लगा हो उस पर आगे निर्माण कर सके।

results.tsv फ़ाइल हर प्रयोग को ट्रैक करती है: कमिट हैश, val_bpb स्कोर, GPU मेमोरी उपयोग, पास/फेल स्थिति, और एजेंट ने क्या करने की कोशिश की उसका विवरण। 

आपको सुबह समीक्षा के लिए एक स्पष्ट ऑडिट ट्रेल मिलता है, और एजेंट अगला क्या आज़माना है यह तय करने के लिए उसी लॉग का उपयोग करता है। शुरुआती प्रयोग व्यापक होते हैं (विभिन्न ऑप्टिमाइज़र कॉन्फ़िग्स की जाँच), जबकि बाद के प्रयोग डेटा द्वारा सत्यापित दिशा पर केंद्रित हो जाते हैं।

AutoResearch के साथ शुरुआत

AutoResearch चलाने के लिए NVIDIA GPU वाली मशीन (डिफ़ॉल्ट कॉन्फ़िगरेशन 20+ GB VRAM वाले आधुनिक GPU को लक्षित करती है), Python 3.10+, uv, और एक कोडिंग एजेंट (Claude Code, Cursor, या समान) की आवश्यकता होती है।

रिपो क्लोन करें, डिपेंडेंसीज़ इंस्टॉल करें, और डेटासेट तैयार करें:

git clone https://github.com/karpathy/autoresearch.git
cd autoresearch
uv sync
uv run prepare.py

कोई ऑर्केस्ट्रेशन स्क्रिप्ट नहीं है। कोई run.py नहीं, कोई पाइपलाइन नहीं, कोई फ़्रेमवर्क नहीं। 

README कहता है कि "बस अपने Claude/Codex या जो भी आप चाहें, उसे इस रिपो में स्पिन-अप करें।" 

आप प्रोजेक्ट डायरेक्टरी में एक कोडिंग एजेंट खोलते हैं, उसे program.md पढ़ने के लिए कहते हैं, और एजेंट अपने आप प्रयोग लूप चला देता है। 

LLM ही ऑटोमेशन लेयर है। प्रगति देखने के लिए results.tsv को टेल करें या git log में नए कमिट देखें।

डिफ़ॉल्ट कॉन्फ़िगरेशन FineWeb-Edu डेटासेट पर एक GPT मॉडल ट्रेन करता है, जिसके लिए एक ठीक-ठाक GPU और परिणाम दिखाने में कई घंटे लगते हैं। छोटे हार्डवेयर पर पहले परीक्षण के लिए, Karpathy TinyStories डेटासेट पर स्विच करने और शब्दावली आकार को 256 तथा गहराई को 4 तक घटाकर मॉडल को स्केल-डाउन करने की सलाह देते हैं। 

ये बदलाव VRAM आवश्यकताओं को कम करते हैं और प्रत्येक प्रयोग को छोटा कर देते हैं ताकि कुछ ही घंटों में रैचेट को क्रियाशील देखा जा सके।

अपना पहला रन कॉन्फ़िगर करना

रात भर का रन शुरू करने से पहले डिफ़ॉल्ट program.md पढ़ें। यह एजेंट द्वारा अपनाए गए अनुसंधान एजेंडा को परिभाषित करता है, और इसे संपादित करके ही आप प्रयोगों को दिशा देते हैं। 

यदि आप चाहते हैं कि एजेंट अटेंशन मैकेनिज़्म पर फोकस करे, तो इसे program.md में लिखें। 

यदि आप चाहते हैं कि वह ऑप्टिमाइज़र को न छुए, तो वह बाधा जोड़ दें। एजेंट वहाँ लिखी बातों से विचलित नहीं होगा।

पहले रात भर के रन के लिए, 80–100 प्रयोग और संभवतः 15–20 सुधारों के रखे जाने की अपेक्षा करें। कुछ व्यावहारिक बातें:

  • API लागतें प्रयोगों की संख्या के साथ बढ़ती हैं। एक रात का रन व्यक्तिगत शोधकर्ताओं के लिए संभालने योग्य है, लेकिन कई दिनों के रन के लिए बजट चाहिए।
  • कुछ प्रयोग क्रैश होंगे। लूप स्वतः रिकवर हो जाता है, इसलिए वे रात भर के रन में बाधा नहीं डालेंगे।
  • सुबह results.tsv देखें, टर्मिनल को न देखें। val_bpb स्कोर के सीढ़ीनुमा पैटर्न व्यक्तिगत लॉग्स से बेहतर कहानी बताते हैं।

AutoResearch के परिणाम और क्रिएटिविटी सीलिंग

AutoResearch को कई रन में परखा गया है—Karpathy के अपने प्रयोगों से लेकर समुदाय द्वारा पुनरुत्पादन और प्रोडक्शन अपनाने तक।

रन

प्रयोग

रखे गए सुधार

परिणाम

प्रारंभिक रात भर (सिंगल GPU)

83

15

val_bpb: 1.000 → 0.975

विस्तारित 2-दिवसीय रन (गहराई-12)

~700

~20

सभी एडिटिव; गहराई-24 मॉडल्स तक ट्रांसफ़र

प्रोडक्शन प्रभाव

-

-

Time-to-GPT-2 बेंचमार्क: 2.02h → 1.80h (11% तेज)

समुदाय सत्र

126

-

val_bpb: 0.9979 → 0.9697

एजेंट ने वे चीज़ें ढूंढीं जो एक व्यवस्थित मानव अंततः ढूंढ लेता। QKnorm में अटेंशन शार्पनिंग के लिए एक स्केलर मल्टिप्लायर गायब था, Value Embeddings को रेगुलराइज़ेशन से लाभ मिला, और बैंडेड अटेंशन ट्यूनिंग, AdamW बीटा पैरामीटर्स, और वेट डिके शेड्यूलिंग में भी लाभ हुए। 

ये संरचनात्मक कोड बदलाव हैं, रैंडम हाइपरपैरामीटर स्वीप्स नहीं, और प्रत्येक को मैन्युअल रूप से जाँचना दिनों लेता।

Shopify के CEO Tobi Lutke ने AutoResearch को एक आंतरिक क्वेरी-एक्सपैंशन मॉडल के लिए अपनाया और 0.8B पैरामीटर मॉडल पर 37 प्रयोगों से वैलिडेशन स्कोर में 19% सुधार प्राप्त किया—शुरू करने के अगले दिन ही परिणाम रिपोर्ट किए।

विभिन्न प्रयोगों में क्रमिक सुधार दिखाती Val BPB सीढ़ी

सीढ़ी चार्ट वास्तविक है, लेकिन हर पायदान छोटा है। एजेंट वास्तविक सुधार ढूंढता है—कहीं बीटा पैरामीटर समायोजित करना, कहीं रेगुलराइज़ेशन जोड़ना। अभी तक किसी ने यह रिपोर्ट नहीं किया कि उसने कोई नया अटेंशन मैकेनिज़्म इजाद किया हो या ऐसा आर्किटेक्चरल विचार प्रस्तावित किया हो जिस तक मानव शोधकर्ता अंततः नहीं पहुँचते।

क्रिएटिविटी सीलिंग

GitHub Issue #22 संरचनात्मक समस्या को समेटता है। एक उपयोगकर्ता ने देखा कि एजेंट जो आख़िरी में काम आया, उसकी मामूली विविधताओं के बीच चक्र लगाता रहता है—स्थानीय खोज पैटर्न में फँसा हुआ। 

रैचेट केवल उन्हीं बदलावों को स्वीकार करता है जो तुरंत val_bpb में सुधार करें, इसलिए एजेंट कभी भी बड़े लाभ के लिए पीछे कदम नहीं रख सकता। 

मानव शोधकर्ता अक्सर तर्क करते हैं, "पहले बदतर होगा, फिर बेहतर।" रैचेट में उसके लिए जगह नहीं है।

Karpathy ने Hacker News पर एक संबंधित समस्या स्वीकार की: एजेंट खुले-अंत वाली समस्याओं पर "चालाक और डरा हुआ" महसूस होता है। 

वे इसे RLHF (Reinforcement Learning from Human Feedback) प्रशिक्षण से जोड़ते हैं, जो साहसी प्रयोग के बजाय सुरक्षित, रूढ़िवादी आउटपुट को पुरस्कृत करता है। एजेंट रचनात्मक बदलाव प्रस्तावित करने में सक्षम है, पर सुरक्षित खेलने के लिए बना है।

निश्चित 5-मिनट का ट्रेनिंग विंडो एक और बाधा जोड़ता है। 

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

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

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

AutoResearch का उपयोग कब करें

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

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

जब प्रयोग मानव की क्षमता से 100 गुना तेज़ चलते हैं, तो ईवाल पाइपलाइन बाधा बन जाती है। स्थिर बेंचमार्क जल्दी सैचुरेट हो जाते हैं। यह पैटर्न अपनाने वाली टीमों को प्रोडक्शन डेटा के साथ विकसित होने वाले ईवाल सेट्स और कठिन एज केसों की ज़रूरत होगी।

Karpathy स्वयं 8x H100 GPUs पर अपने प्रोडक्शन nanochat फ़्रेमवर्क के साथ AutoResearch के "बड़े कज़िन" को चलाते हैं, जो दर्शाता है कि यह पैटर्न खिलौना-प्रयोगों से आगे स्केल करता है। समुदाय ने इसे पहले ही macOS/Apple Silicon के लिए फोर्क कर लिया है और पुराने GPUs के लिए इंटीग्रेशन प्रस्तावित किए हैं। CPU बनाम GPU गाइड बताता है कि इस तरह की पुनरावृत्त ट्रेनिंग के लिए GPU हार्डवेयर अनिवार्य क्यों है।

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

निष्कर्ष

एक अच्छा program.md लिखने के लिए आपको स्वयं शोध किया होना चाहिए। आपको पता होना चाहिए कि किन दिशाओं को आज़माना सार्थक है, आपकी समस्या के लिए "बेहतर" का अर्थ क्या है, और कब क्रमिक लाभ अपनी सीमा पर पहुँच चुके हैं। एजेंट निष्पादन संभालता है, पर शोध एजेंडा के पीछे की सूझबूझ मानव ही रहती है। यदि अगली पीढ़ी के इंजीनियर वह बुनियादी काम छोड़ दें क्योंकि अब एजेंट्स उसे संभालते हैं, तो क्षेत्र के पास भरपूर compute होगा—पर उसे सही दिशा देने का अनुभव रखने वाले लोग नहीं।

AutoResearch FAQs

AutoResearch क्या है?

AutoResearch, Andrej Karpathy का एक ओपन-सोर्स Python टूल है जो एक AI कोडिंग एजेंट को बिना मानवीय हस्तक्षेप के एकल GPU पर ML प्रयोग चलाने देता है। यह प्रस्ताव-प्रशिक्षण-मूल्यांकन चक्रों से गुजरता है, केवल वे बदलाव रखता है जो वैलिडेशन लॉस में सुधार करें, और बाकी को git revert के माध्यम से त्याग देता है।

AutoResearch रैचेट लूप कैसे काम करता है?

एजेंट शोध दिशा के लिए program.md फ़ाइल पढ़ता है, प्रस्तावित बदलाव के साथ train.py को संशोधित करता है, उसे कमिट करता है, ठीक 5 मिनट के लिए ट्रेनिंग चलाता है, और val_bpb का उपयोग करके परिणाम का मूल्यांकन करता है। यदि स्कोर में सुधार होता है, तो कमिट बना रहता है। यदि नहीं, तो git reset उसे रिवर्ट कर देता है। फिर चक्र स्वतः दोहरता है। skills override managed ones, which override bundled skills with the same name.

AutoResearch में तीन-फ़ाइल आर्किटेक्चर क्या है?

AutoResearch तीन फ़ाइलों का उपयोग करता है जिन पर सख्त स्वामित्व नियम लागू हैं। prepare.py अपरिवर्तनीय है और मूल्यांकन संभालती है। train.py एजेंट का सैंडबॉक्स है जहाँ वह कोई भी कोड संशोधित कर सकता है। program.md इंसान द्वारा लिखी जाती है और शोध दिशाएँ, बाधाएँ, और प्रयोग नियम परिभाषित करती है। कोई पक्ष दूसरे की फ़ाइल नहीं छू सकता।

AutoResearch की सीमाएँ क्या हैं?

मुख्य सीमा क्रिएटिविटी सीलिंग है। क्योंकि रैचेट केवल उन बदलावों को रखता है जो तुरंत val_bpb में सुधार करें, एजेंट बड़े लाभ की तैयारी के लिए पीछे कदम नहीं रख सकता। वह आख़िर में काम आए हुए विचारों की मामूली विविधताओं के बीच घूमता रहता है—संरचनात्मक खोजों की बजाय क्रमिक सुधार ढूँढता है।

AutoResearch, AutoML और AlphaEvolve से कैसे अलग है?

AutoML और NAS फ़्रेमवर्क पूर्व-परिभाषित पैरामीटर स्पेस में संरचित अल्गोरिथ्मों से खोज करते हैं। AlphaEvolve Gemini मॉडल्स के साथ evolutionary तरीके अपनाता है लेकिन क्लोज़्ड-सोर्स है। AutoResearch LLM को मनचाहा कोड संशोधित करने की स्वतंत्रता देता है—सीमित सर्च स्पेस के बजाय सामान्य ज्ञान पर दांव लगाकर—और यह MIT लाइसेंस के तहत पूर्णतः ओपन-सोर्स है।

Bexruz (Bex) Tuychiev

लेखक

Bexruz (Bex) Tuychiev

मैं 2 से अधिक वर्षों के अनुभव वाला डेटा साइंस कंटेंट क्रिएटर हूँ और Medium पर सबसे बड़े फॉलोइंग्स में से एक रखता हूँ। मुझे एआई और एमएल पर विस्तार से लेख लिखना पसंद है, जिसमें हल्का-सा व्यंग्यात्मक अंदाज रहता है—क्योंकि कुछ तो करना पड़ता है ताकि वे कम उबाऊ लगें। मैंने 130 से अधिक लेख और एक DataCamp कोर्स तैयार किया है, और एक और बन रहा है। मेरा कंटेंट 50 लाख से अधिक लोगों ने देखा है, जिनमें से 20 हज़ार लोग Medium और LinkedIn पर फॉलोअर्स बन गए। 

विषय