योजना + loop पहरेदार
जो agent काम कर सकता है वह हमेशा भी कर सकता है। एक असली agent के पैसे जलाने और एक on-call engineer को page करने का नंबर एक तरीका बिना ब्रेक का loop है: वह वही tool बुलाता रहता है, वही observation पाता है, और कभी तय नहीं करता कि वह पूरा हो गया। यह पाठ वे दो चीज़ें जोड़ता है जो agent को सचमुच चलाने के लिए सुरक्षित बनाती हैं: एक छोटा योजनाकार जो लक्ष्य को क्रमबद्ध उप-कामों में तोड़ता है, और एक loop पहरेदार जो agent को बेक़ाबू होने से पहले रोकता है।
पहले, योजना। decompose(goal) एक-पंक्ति लक्ष्य को उप-कामों की क्रमांकित सूची में बदलता है। हम इसे निश्चित और नियम-आधारित रखते हैं (production में LLM यह करता है, पर आकार मायने रखता है): लक्ष्य को शब्द "then" पर split करें, हर टुकड़ा strip करें, और उन्हें 1 से क्रमांक दें।
decompose("find the team size then multiply by 2 then report")
# ["1. find the team size", "2. multiply by 2", "3. report"]अब पहरेदार। run_with_guard(policy, state, max_steps) एक नीति को क़दम दर क़दम चलाता है, पर बेक़ाबू होने से मना करता है। यहाँ एक नीति एक फ़ंक्शन policy(state) -> action है (वह काम बताने वाली स्ट्रिंग जो वह करना चाहती है); एक काम लगाना बस उसे इतिहास सूची में जोड़ता है। पहरेदार तीन में से एक कारण से रुकता है और बताता है कौन-सा:
- पूरा: नीति काम
"done"लौटाती है -> कारण"done"के साथ रुकें। - कोई प्रगति नहीं: नीति लगातार दो बार वही काम लौटाती है -> कारण
"repeat"के साथ रुकें। यह loop में फँसने का क्लासिक संकेत है: agent अपने observations से नहीं सीख रहा। - बजट: यह पूरा हुए बिना
max_stepsतक पहुँचता है -> कारण"max_steps"के साथ रुकें।
def run_with_guard(policy, state, max_steps):
history = []
for _ in range(max_steps):
action = policy(state)
if action == "done":
return {"history": history, "reason": "done"}
if history and action == history[-1]:
return {"history": history, "reason": "repeat"}
history.append(action)
# let the policy advance its own state here
...
return {"history": history, "reason": "max_steps"}एक dict {"history": [...], "reason": ...} लौटाएँ। "repeat" जाँच आपको बचाती है: एक बग वाली या उलझी नीति जो हमेशा "search" देती रहती है दूसरे एक जैसे काम पर रोकी जाती है, एक कारण के साथ जिसे आप लॉग और चेतावनी दे सकें। प्रगति करके फिर "done" कहने वाली अच्छे बर्ताव की नीति अपने बजट के अंदर साफ़ पूरी होती है। ग्रेडर जाँचता है कि loop करने वाली नीति "repeat" के साथ रुके, बेक़ाबू नीति "max_steps" तक पहुँचे, और अच्छी नीति "done" के साथ पूरी हो, और साथ में कि decompose सही क्रमांक दे। तीनों नतीजे देखने के लिए Run दबाएँ।
decompose(goal) लिखें: goal को " then " पर split करें, हर हिस्सा strip करें, और उन्हें "1. part", "2. part", ... के रूप में लौटाएँ। फिर run_with_guard(policy, state, max_steps) लिखें जहाँ policy(state) एक काम स्ट्रिंग लौटाता है। नीति को max_steps बार तक चलाएँ और {"history": [...], "reason": ...} लौटाएँ: काम "done" होने पर कारण "done" के साथ रुकें; कोई काम ठीक पिछले वाले के बराबर हो (कोई प्रगति नहीं) तो कारण "repeat" के साथ रुकें; बजट ख़त्म हो तो कारण "max_steps" के साथ रुकें। हर स्वीकार किया काम history में जोड़ें।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।