Intent classification (TF-IDF + LogisticRegression)
हर "AI feature" को बड़े भाषा मॉडल की ज़रूरत नहीं होती। production LLM ऐप का एक बड़ा हिस्सा मॉडल के सामने एक छोटा, उबाऊ classifier रखता है: वह आने वाला संदेश पढ़ता है, तय करता है कि यह किस तरह का अनुरोध है (billing? bug report? account बदलाव?), और उसी के हिसाब से आगे भेजता है। वह फ़ैसला तेज़, मुफ़्त, offline चलने वाला, और निश्चित है -> एक ही इनपुट हमेशा एक ही जवाब देता है। आप महँगा LLM कॉल तभी करते हैं जब सचमुच ज़रूरत हो।
छोटे टेक्स्ट के लिए मुख्य औज़ार TfidfVectorizer + LogisticRegression है। TF-IDF हर संदेश को भारित शब्द-गिनतियों के एक विरल vector में बदलता है; logistic regression intent classes के बीच एक linear सीमा सीखता है। कुछ दर्जन labelled उदाहरणों पर यह milliseconds में train होता है और microseconds में classify करता है।
आप दोनों को एक Pipeline से एक ऑब्जेक्ट में जोड़ेंगे ताकि vectorizer और classifier एक इकाई के रूप में साथ fit और लागू हों:
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
pipe = Pipeline([
("tfidf", TfidfVectorizer()),
("clf", LogisticRegression(random_state=0, max_iter=1000)),
])
pipe.fit(texts, labels)
pipe.predict(["can I get a refund"]) # -> array(['billing'])random_state=0 क्यों? रखने लायक एक आदत। यहाँ का डिफ़ॉल्ट solver (lbfgs) निश्चित है, इसलिए यह pipeline seed के साथ या बिना वही weights देती है। पर दूसरे solvers (saga, liblinear) डेटा फेंटते हैं, और कई scikit-learn मॉडल (random forests, k-means, train/test splits) बनावट से ही रैंडम हैं; वहाँ seed ही training को दोहराने लायक बनाता है। इसे हर जगह लिखने का मतलब है कि बाद में solver या मॉडल बदलने से आपकी routing चुपचाप हर बार न पलटे। कोर्स यह नियम हर जगह मानता है।
LLM से ठीक यही अंतर है। एक मॉडल कॉल अनिश्चित है, पैसे लेता है, और देरी जोड़ता है। intent पता चलने के बाद आप आगे जिस तरह का fallback जोड़ सकते हैं वह यह है (संदर्भ के लिए दिखाया गया, कभी ग्रेड नहीं होता):
# Pseudocode: only AFTER the cheap classifier is unsure do you reach for the model.
intent = pipe.predict([msg])[0]
if intent == "general":
reply = await window._floatiTutor.complete(msg) # the on-device LLMदो फ़ंक्शन बनाएँ। train_classifier(texts, labels) एक fit हुई Pipeline लौटाता है (TF-IDF + random_state=0 के साथ LogisticRegression)। predict(model, new_texts) वह मॉडल और स्ट्रिंग की एक सूची लेता है और अनुमानित labels की एक सूची लौटाता है। एक छोटे support-ticket set पर train करने और अलग रखे संदेशों को सही टीम तक जाते देखने के लिए Run दबाएँ।
train_classifier(texts, labels) लिखें जो TfidfVectorizer() फिर LogisticRegression(random_state=0, ...) वाली एक fit हुई sklearn Pipeline लौटाए, और predict(model, new_texts) जो इनपुट स्ट्रिंग की सूची के लिए अनुमानित labels की सूची लौटाए। seed इसे दोहराने लायक बनाता है; classifier को अलग रखे अलग-अलग संदेशों को उनके सही intents तक भेजना होगा। शुरुआती कोड के TEXTS और LABELS जैसे हैं वैसे रखें: जाँच उन्हें पढ़ती है।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।