पाठ्यक्रम 250 में से पाठ 197 · LLM के चारों ओर का ML
LLM के चारों ओर का ML

Embedding से prototype तक routing

classifier को labelled training डेटा चाहिए। कभी-कभी आपके पास कोई नहीं होता -> बस हर intent के लिए कुछ उदाहरण queries होती हैं। तब सबसे सस्ता router सबसे पास का prototype है: हर intent को एक vector से दर्शाएँ (उसका "prototype", अक्सर कुछ उदाहरणों का औसत embedding), आने वाली query को embed करें, और उसे उस prototype तक भेजें जिसकी ओर वह सबसे सीधे इशारा करती है।

"सबसे सीधे इशारा करना" का मतलब है cosine similarity: दो vectors के बीच के कोण का cosine, उनकी लंबाई को नज़रअंदाज़ करते हुए। टेक्स्ट के लिए यही सही माप है क्योंकि एक ही विषय पर एक लंबा और एक छोटा दस्तावेज़ फिर भी मेल खाना चाहिए।

cosine(a, b) = (a . b) / (|a| |b|)

1.0 के पास का मान मतलब vectors एक ही दिशा में इशारा करते हैं (एक ही intent); 0.0 के पास मतलब असंबंधित। router सबसे ऊँचे cosine वाला prototype चुनता है, और वह score एक confidence का भी काम करता है जिस पर आप बाद में सीमा लगा सकते हैं।

ईमानदार बात: production में वे vectors एक train किए embedding मॉडल से आते हैं (एक API कॉल, या एक sentence-transformer)। हम यहाँ एक लोड नहीं कर सकते -> ब्राउज़र में न कोई model weights फ़ाइल है न GPU। इसलिए इस पाठ में vectors आपको सादे numpy ऐरे के रूप में दिए गए हैं। आप routing की ज्यामिति बना रहे हैं, जो एक जैसी है चाहे संख्याएँ असली embedder से आईं या fixture से। असली embeddings बस बेहतर संख्याएँ भरते हैं; cosine-और-argmax वाला तर्क ही वह हिस्सा है जो आप भेजते हैं।

बराबरी निश्चित ढंग से टूटनी चाहिए। अगर दो prototypes ठीक बराबर दूरी पर हैं, तो "जो dict में पहले आ जाए" चुनना एक छिपा बग है -> dict का क्रम बदल सकता है। बराबरी उस intent को चुनकर तोड़ें जिसका नाम वर्णक्रम में पहले आता है, ताकि वही बराबरी हमेशा उसी तरह सुलझे।

दो फ़ंक्शन बनाएँ। cosine(a, b) दो vectors की cosine similarity लौटाता है और शून्य से सुरक्षित है (शून्य लंबाई वाला vector 0.0 लौटाता है, कभी NaN नहीं)। route_by_prototype(query_vec, prototypes) query vector और एक dict {intent_name: prototype_vector} लेता है और tuple (best_intent, best_score) लौटाता है -> सबसे पास का prototype और उसका cosine, वर्णक्रम वाले टाई-ब्रेक के साथ। कुछ queries को route करने और हर एक का confidence देखने के लिए Run दबाएँ।

आपकी बारी

cosine(a, b) = a.b / (|a||b|) लिखें, जो किसी भी vector की लंबाई शून्य होने पर 0.0 लौटाए (कोई NaN नहीं)। फिर route_by_prototype(query_vec, prototypes) लिखें जहाँ prototypes एक dict {name: vector} है; सबसे ऊँचे cosine के लिए tuple (best_name, best_score) लौटाएँ, ठीक बराबरी को वर्णक्रम में पहले नाम से तोड़ते हुए। शुरुआती कोड का PROTOTYPES जैसा है वैसा रखें: जाँच उसे पढ़ती है।

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

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

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