पाठ्यक्रम 250 में से पाठ 233 · प्रोजेक्ट: tool इस्तेमाल करने वाला research agent
प्रोजेक्ट: tool इस्तेमाल करने वाला research agent

agent trace परखें

प्रोजेक्ट का आख़िरी टुकड़ा वह है जो सबसे ज़्यादा छोड़ा जाता है और resume पर सबसे ज़्यादा मायने रखता है: परखना। कोई भी demo में चलने वाला agent जोड़ सकता है। नौकरी पाने वाला engineer वह है जो साबित कर सके कि यह काम करता है, पकड़ सके कि कब यह चुपचाप ग़लत करता है, और जवाब न दे पाने पर शालीनता से विफल हो। आप अपने agent के बनाए trace को score करेंगे और उसके हार मानने के लिए एक विकल्प जोड़ेंगे।

पाठ 2 का trace याद करें: (thought, tool, args, observation) tuples की क्रमबद्ध सूची। एक दौर को ग्रेड करने के लिए आप तुलना करते हैं कि agent ने असल में क्या किया और उसे क्या करना था।

score_run(trace, expected_tools, expected_answer) लिखें जो तीन fields वाली dict लौटाए:

  • "tools_ok": क्या agent ने सही tools सही क्रम में इस्तेमाल किए? हर क़दम से tool नाम निकालें और क्रम की तुलना expected_tools से करें। ग़लत या ग़ायब tool इसे False बनाता है। इसी तरह आप उस agent को पकड़ते हैं जो सही जवाब तक ग़लत रास्ते से पहुँचा (जो अगले इनपुट पर टूटेगा)।
  • "answer_ok": क्या आख़िरी क़दम ने सही जवाब दिया? आख़िरी जवाब आख़िरी क़दम का observation है। इसकी तुलना expected_answer से करें। जिस दौर ने कभी जवाब नहीं दिया (ख़ाली trace) वह answer_ok = False है।
  • "steps": दौर ने कितने क़दम लिए (len(trace)) -> आपका लागत/देरी संकेत।
def score_run(trace, expected_tools, expected_answer):
    tools_used = [tool for (_thought, tool, _args, _obs) in trace]
    final = trace[-1][3] if trace else None
    return {
        "tools_ok": tools_used == list(expected_tools),
        "answer_ok": bool(trace) and final == expected_answer,
        "steps": len(trace),
    }

फिर सुरक्षा जाल। answer_or_fallback(trace) live अनुरोधों पर चलता है, जहाँ किसी को सही जवाब नहीं पता, इसलिए यह किसी से तुलना नहीं कर सकता (वह score_run offline, आपके test set पर करता है)। यह दौर पर तभी भरोसा करता है जब आख़िरी क़दम एक असली जवाब वाला finish क़दम हो, और नहीं तो तय स्ट्रिंग "unable to answer" लौटाता है: जो दौर अपनी क़दम सीमा तक पहुँचा, एक search पर रुका, या "not found" पर ख़त्म हुआ। production में यही आप उपयोगकर्ता को एक hallucination या stack trace के बजाय लौटाते हैं।

def answer_or_fallback(trace):
    # At serving time there is no expected answer to compare with. Trust a run
    # only if it ended with a finish step carrying a real answer.
    if not trace:
        return "unable to answer"
    _thought, tool, _args, observation = trace[-1]
    if tool != "finish" or observation in (None, "not found"):
        return "unable to answer"
    return observation

ग्रेडर एक सही दौर (सब कुछ True), ग़लत tool इस्तेमाल करने वाला दौर (tools_ok False है पर जवाब फिर भी मेल खा सकता है), और बिना जवाब वाला दौर (answer_ok False है) देता है, और साथ में एक इनलाइन संदर्भ से तुलना किए रैंडम traces ताकि कोई स्थिरांक scorer न फिसले। इसे हरा करें और मुख्य पंक्ति अपने आप लिखी जाती है: loop पहरेदारों और trace eval के साथ tool इस्तेमाल करने वाला ReAct agent बनाया। Run दबाएँ।

आपकी बारी

(thought, tool, args, observation) tuples के trace पर score_run(trace, expected_tools, expected_answer) लिखें, जो {"tools_ok", "answer_ok", "steps"} लौटाए: tools_ok है कि tool नामों का क्रम expected_tools के बराबर है या नहीं; answer_ok है कि आख़िरी क़दम का observation expected_answer के बराबर है या नहीं (ख़ाली trace के लिए False); steps है len(trace)। फिर answer_or_fallback(trace) लिखें, live अनुरोध पर चलाई जाने वाली जाँच, जहाँ कोई अपेक्षित जवाब नहीं: आख़िरी observation सिर्फ़ तब लौटाएँ जब आख़िरी क़दम एक "finish" क़दम हो और उसका observation न None न "not found" हो; नहीं तो स्ट्रिंग "unable to answer" लौटाएँ। (score_run आपके offline test set के लिए है, जहाँ आप जवाब जानते हैं; answer_or_fallback production के लिए है, जहाँ नहीं जानते।)

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।