वर्गीकरण माप: Accuracy, Precision, Recall, F1
शिक्षार्थी उन्हीं पूर्वानुमानों पर चारों मापों की गणना करेंगे और समझेंगे कि गलत धनात्मक तथा गलत ऋणात्मक की लागत के आधार पर किसे प्राथमिकता देनी चाहिए।
वर्गीकरण माप: Accuracy, Precision, Recall, F1, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
Accuracy अक्सर पर्याप्त क्यों नहीं होती
Accuracy — सही predictions का अंश — सबसे सहज मेट्रिक है, लेकिन classes के असंतुलित होने पर यह भ्रामक होती है। ऐसे चिकित्सीय test पर विचार कीजिए जिसमें 1% रोगियों को कोई बीमारी प्रभावित करती है। ऐसा model जो हमेशा 'स्वस्थ' का prediction करता है, 99% accuracy प्राप्त कर सकता है, फिर भी पूरी तरह अनुपयोगी होता है — वह बीमारी के प्रत्येक वास्तविक मामले को चूक जाता है। धोखाधड़ी का पता लगाने, कैंसर की जाँच या दुर्लभ घटनाओं के prediction में, accuracy model की दुर्लभ लेकिन महत्वपूर्ण positive class का पता लगाने में हुई विफलता को छिपा देती है। इसलिए हमें ऐसे मेट्रिक्स चाहिए जो प्रत्येक class पर performance को अलग-अलग मापें: precision, recall और F1-score।
import numpy as np
# 1000 patients: 990 healthy, 10 sick
y_true = [0]*990 + [1]*10
y_pred_dummy = [0]*1000 # Always predict healthy
correct = sum(p == t for p, t in zip(y_pred_dummy, y_true))
accuracy = correct / len(y_true)
print(f'Dummy accuracy: {accuracy:.1%}') # 99.0% -- misleadingly high!
print('But 0 sick patients correctly identified!')
print('This is why we need precision and recall.')Confusion Matrix: वास्तविक स्थिति
confusion matrix सभी classification metrics का आधार है। binary classification के लिए यह 2x2 table होती है: True Positives (TP) — सही रूप से predicted positive; True Negatives (TN) — सही रूप से predicted negative; False Positives (FP) — positive predicted, लेकिन वास्तव में negative (Type I error); False Negatives (FN) — negative predicted, लेकिन वास्तव में positive (Type II error)। प्रत्येक classification metric इन चार संख्याओं के किसी संयोजन से निकाला जाता है। कच्ची confusion matrix का निरीक्षण करने से पता चलता है कि model किस प्रकार का error सबसे अधिक करता है।
from sklearn.metrics import confusion_matrix
import numpy as np
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 0, 0]
cm = confusion_matrix(y_true, y_pred)
print('Confusion Matrix:')
print(cm)
# [[TN, FP],
# [FN, TP]]
TN, FP, FN, TP = cm.ravel()
print(f'TP={TP}, TN={TN}, FP={FP}, FN={FN}')Accuracy: सरल लेकिन सीमित
Accuracy = (TP + TN) / (TP + TN + FP + FN)। यह बताती है: सभी predictions में से सही predictions का अंश कितना था? Accuracy केवल तभी उचित मेट्रिक है जब classes लगभग संतुलित हों और false positives तथा false negatives की लागत समान हो। उदाहरण के लिए, हस्तलिखित अंकों की पहचान में प्रत्येक digit class लगभग 10% होती है, इसलिए dataset संतुलित होता है और accuracy एक उचित माप बनती है। accuracy का उपयोग तब करें जब: classes संतुलित हों और सभी errors की लागत समान हो। इससे बचें जब: classes असंतुलित हों (एक class का प्रभुत्व हो) या false negatives की लागत false positives से अधिक हो (या इसके विपरीत)।
from sklearn.metrics import accuracy_score, confusion_matrix
import numpy as np
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 0, 0]
acc = accuracy_score(y_true, y_pred)
print(f'Accuracy = {acc:.2f}') # (TP+TN) / total
# Manual calculation
TN, FP, FN, TP = confusion_matrix(y_true, y_pred).ravel()
acc_manual = (TP + TN) / (TP + TN + FP + FN)
print(f'Manual: ({TP}+{TN}) / ({TP}+{TN}+{FP}+{FN}) = {acc_manual:.2f}')Precision: Positive Predictions की गुणवत्ता
Precision = TP / (TP + FP)। यह बताती है: जिन सभी samples को हमने positive predicted किया, उनमें से वास्तव में positive samples का अंश कितना है? जब false positives महँगे हों, तब precision को optimize करना चाहिए। Spam detection में high-precision spam filter वैध email को शायद ही कभी spam के रूप में चिह्नित करता है। Drug testing में high precision का अर्थ है कि हम ऐसे drug को शायद ही कभी approve करते हैं जो काम नहीं करता। Low precision का अर्थ है कि हमारी कई positive predictions गलत हैं — हम users को false alarms से भर रहे हैं। Precision false negatives के बारे में कुछ नहीं बताती — केवल एक स्पष्ट case को positive predict करने वाले model की precision 1.0 हो सकती है, लेकिन वह बाकी सब कुछ चूक जाता है।
from sklearn.metrics import precision_score, confusion_matrix
import numpy as np
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 0, 0]
prec = precision_score(y_true, y_pred)
print(f'Precision = {prec:.2f}')
# Manual calculation
TN, FP, FN, TP = confusion_matrix(y_true, y_pred).ravel()
print(f'Manual: TP/(TP+FP) = {TP}/({TP}+{FP}) = {TP/(TP+FP):.2f}')
print('Of all PREDICTED positives, this fraction are truly positive.')Recall: वास्तविक Positives का कवरेज
Recall = TP / (TP + FN) (इसे Sensitivity या True Positive Rate भी कहा जाता है)। यह बताती है: वास्तव में positive सभी samples में से हमने कितने अंश को ढूँढ़ लिया? जब false negatives महँगे हों, तब recall को optimize करना चाहिए। कैंसर की जाँच में high recall का अर्थ है कि हम वास्तव में कैंसर से पीड़ित अधिकांश रोगियों की पहचान कर लेते हैं। धोखाधड़ी का पता लगाने में high recall का अर्थ है कि हम अधिकांश fraudulent transactions पकड़ लेते हैं। Low recall का अर्थ है कि हम बहुत अधिक वास्तविक positives चूक रहे हैं — चिकित्सीय या सुरक्षा संदर्भों में यह खतरनाक है। Recall और precision के बीच तनाव होता है: सामान्यतः एक को बढ़ाने पर दूसरा घटता है।
from sklearn.metrics import recall_score, confusion_matrix
import numpy as np
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 0, 0]
rec = recall_score(y_true, y_pred)
print(f'Recall = {rec:.2f}')
# Manual calculation
TN, FP, FN, TP = confusion_matrix(y_true, y_pred).ravel()
print(f'Manual: TP/(TP+FN) = {TP}/({TP}+{FN}) = {TP/(TP+FN):.2f}')
print('Of all ACTUAL positives, this fraction were correctly identified.')Precision-Recall का संतुलन
Classification threshold को समायोजित करने पर precision और recall का संबंध उलटा होता है। जैसे-जैसे आप threshold कम करते हैं (अधिक आक्रामक ढंग से positive predict करते हैं), recall बढ़ता है (आप अधिक वास्तविक positives पकड़ते हैं), लेकिन precision घटता है (अधिक false positives निकल जाते हैं)। Threshold बढ़ाने पर इसका उलटा प्रभाव होता है। ऐसा कोई एक threshold नहीं है जो दोनों को एक साथ अधिकतम कर सके। किस metric को प्राथमिकता देनी है, यह business problem पर निर्भर करता है: email filtering में precision को प्राथमिकता दें (users को false spam alerts से परेशान न करें); disease screening में recall को प्राथमिकता दें (बीमार रोगियों को न चूकें)।
from sklearn.metrics import precision_score, recall_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)
clf = LogisticRegression(max_iter=10000)
clf.fit(X_tr, y_tr)
proba = clf.predict_proba(X_te)[:, 1]
for thresh in [0.3, 0.5, 0.7, 0.9]:
y_pred = (proba >= thresh).astype(int)
prec = precision_score(y_te, y_pred, zero_division=0)
rec = recall_score(y_te, y_pred)
print(f'threshold={thresh}: precision={prec:.3f}, recall={rec:.3f}')F1-Score: Precision और Recall का Harmonic Mean
F1-score = 2 * (Precision * Recall) / (Precision + Recall)। F1-score precision और recall का harmonic mean है। Arithmetic mean के विपरीत, harmonic mean अत्यधिक मानों को दंडित करता है: precision=1.0 और recall=0.0 वाले model को F1=0 मिलता है, 0.5 नहीं। इससे F1 एक उचित aggregate metric बनता है, जिसके लिए दोनों precision और recall का पर्याप्त रूप से अधिक होना आवश्यक है। असंतुलित text classification (NLP benchmarks में इसकी हमेशा report दी जाती है), धोखाधड़ी का पता लगाने और ऐसी किसी भी समस्या में F1 standard metric है जहाँ class imbalance accuracy को भ्रामक बनाता है।
from sklearn.metrics import f1_score, precision_score, recall_score
import numpy as np
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 0, 0]
prec = precision_score(y_true, y_pred)
rec = recall_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred)
print(f'Precision = {prec:.3f}')
print(f'Recall = {rec:.3f}')
print(f'F1-Score = {f1:.3f}')
print(f'Manual F1 = 2 * ({prec:.3f} * {rec:.3f}) / ({prec:.3f} + {rec:.3f}) = {2*prec*rec/(prec+rec):.3f}')Fbeta-Score: Weighted Precision-Recall संतुलन
Fbeta score beta नामक parameter जोड़कर F1 को सामान्यीकृत करता है, जो यह नियंत्रित करता है कि precision की तुलना में recall को कितना weight दिया जाए: F_beta = (1 + beta^2) * Precision * Recall / (beta^2 * Precision + Recall)। जब beta=1 होता है, तो यह standard F1 score होता है। जब beta=2 (F2) होता है, तो recall को precision की तुलना में दोगुना weight दिया जाता है — यह तब उपयोगी है जब positives को चूकने की लागत false alarms से दोगुनी हो। जब beta=0.5 (F0.5) होता है, तो precision को अधिक weight दिया जाता है — यह recommendation systems में उपयोगी है, जहाँ suggestions की accuracy coverage से अधिक महत्वपूर्ण होती है।
from sklearn.metrics import fbeta_score
import numpy as np
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 0, 0]
for beta in [0.5, 1.0, 2.0]:
score = fbeta_score(y_true, y_pred, beta=beta)
print(f'F{beta:.1f} = {score:.3f}')
print()
print('beta=0.5: precision weighted 2x -> use when false alarms costly')
print('beta=1.0: balanced precision/recall -> standard F1')
print('beta=2.0: recall weighted 2x -> use when missing positives costly')Multi-Class Averaging: Macro, Micro और Weighted
Multi-class classification के लिए आपको प्रत्येक class की precision/recall/F1 को एक संख्या में aggregate करना होता है। Macro average: प्रत्येक class के लिए metric स्वतंत्र रूप से निकालें, फिर उनका average लें — class के आकार की परवाह किए बिना सभी classes को समान मानता है। Weighted average: यही प्रक्रिया, लेकिन class support के आधार पर weight के साथ — बड़ी classes को अधिक प्रभाव देता है। Micro average: पहले सभी classes के TP/FP/FN को aggregate करें, फिर गणना करें — जब किसी sample के कई labels न हों, तब precision, recall और F1 के लिए यह accuracy के बराबर होता है। असंतुलित datasets के लिए macro का उपयोग करें, जहाँ छोटी minority classes महत्वपूर्ण होती हैं।
from sklearn.metrics import f1_score
import numpy as np
# Multi-class predictions
y_true = [0, 0, 1, 1, 2, 2, 2]
y_pred = [0, 1, 1, 1, 2, 0, 2]
print('Macro F1: ', f1_score(y_true, y_pred, average='macro').round(3))
print('Micro F1: ', f1_score(y_true, y_pred, average='micro').round(3))
print('Weighted F1: ', f1_score(y_true, y_pred, average='weighted').round(3))
print('Per-class F1:', f1_score(y_true, y_pred, average=None).round(3))
print()
print('Macro treats all classes equally (even rare ones)')
print('Weighted rewards correct prediction of common classes')classification_report: सभी Metrics एक साथ
classification_report() एक formatted table बनाता है जिसमें प्रत्येक class के लिए precision, recall, F1-score और support (वास्तविक instances की संख्या), साथ ही macro/weighted averages दिखाई जाती हैं। यह किसी भी ML evaluation report में शामिल किया जाने वाला standard output है। 'support' column विशेष रूप से महत्वपूर्ण है: support=5 वाली class के precision/recall estimates noisy होंगे और उनकी व्याख्या सावधानी से की जानी चाहिए। Metric की reliability आँकने के लिए F1 scores के साथ support values को हमेशा जाँचें।
from sklearn.metrics import classification_report
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42)
clf = RandomForestClassifier(random_state=42)
clf.fit(X_tr, y_tr)
y_pred = clf.predict(X_te)
print(classification_report(
y_te, y_pred,
target_names=load_iris().target_names
))असंतुलित Classes के लिए Balanced Accuracy
Balanced accuracy sensitivity (प्रत्येक class के लिए recall) का arithmetic mean है। Binary classification के लिए: balanced_accuracy = (TPR + TNR) / 2, जहाँ TNR (True Negative Rate) = TN / (TN+FP)। Standard accuracy के विपरीत, balanced accuracy प्रत्येक class को उसके samples की संख्या की परवाह किए बिना समान weight देती है। जो model हमेशा majority class का prediction करता है, उसकी balanced accuracy 0.5 होती है — इससे सही रूप से पता चलता है कि वह random से बेहतर नहीं है। जब classes असंतुलित हों और आपको एक single metric चाहिए, तब balanced accuracy का उपयोग करें जो प्रत्येक class पर performance को समान रूप से दर्शाए, बिना per-class metrics निकालने की जटिलता के।
from sklearn.metrics import balanced_accuracy_score, accuracy_score
import numpy as np
# Imbalanced: 990 class 0, 10 class 1
y_true = np.array([0]*990 + [1]*10)
y_dummy = np.zeros(1000, dtype=int) # Always predict class 0
acc_standard = accuracy_score(y_true, y_dummy)
acc_balanced = balanced_accuracy_score(y_true, y_dummy)
print(f'Standard accuracy: {acc_standard:.3f}') # 99% -- misleading
print(f'Balanced accuracy: {acc_balanced:.3f}') # 0.5 -- correctly shows no skill
print()
print('Balanced accuracy correctly penalises ignoring the minority class')त्वरित जाँच
इस पाठ में दिए गए Python के साथ Machine Learning संबंधी concepts की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: असंतुलित classes के लिए accuracy भ्रामक होती है — ground truth के रूप में confusion matrix का उपयोग करें, precision positive predictions की गुणवत्ता मापती है (false positives को कम करें) और recall वास्तविक positives के coverage को मापती है (false negatives को कम करें), तथा F1-score दोनों को harmonically जोड़कर एक संतुलित metric बनाता है। अब हम threshold-independent model evaluation के लिए ROC curves और AUC-ROC का अध्ययन करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “वर्गीकरण माप: Accuracy, Precision, Recall, F1” पाठ निःशुल्क है?
हाँ—“वर्गीकरण माप: Accuracy, Precision, Recall, F1” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“वर्गीकरण माप: Accuracy, Precision, Recall, F1” में मैं क्या सीखूँगा?
शिक्षार्थी उन्हीं पूर्वानुमानों पर चारों मापों की गणना करेंगे और समझेंगे कि गलत धनात्मक तथा गलत ऋणात्मक की लागत के आधार पर किसे प्राथमिकता देनी चाहिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“वर्गीकरण माप: Accuracy, Precision, Recall, F1” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- वर्गीकरण माप: Accuracy, Precision, Recall, F1
- ROC वक्र और AUC-ROC
- प्रतिगमन माप: MAE, MSE, RMSE और R-Squared
- अपने व्यावसायिक प्रश्न के लिए सही माप चुनना