> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/models/hi/evaluate/evaluate-trained-models.md). # प्रशिक्षित मॉडलों का मूल्यांकन करें अपने टेस्ट डेटासेट पर आपका मॉडल कैसा प्रदर्शन करता है, यह जानने के लिए Model Evaluation का उपयोग करें। ## के बारे में मॉडल मूल्यांकन दिखाते हैं: 1. एक प्रोडक्शन मेट्रिक्स एक्सप्लोरर, जो आपको वह सर्वोत्तम confidence threshold खोजने में मदद करता है जिस पर आप अपना मॉडल चला सकें; 2. मॉडल सुधार सिफारिशें, जो बताती हैं कि आप अपने मॉडल की सटीकता कैसे बढ़ा सकते हैं; 3. क्लास के अनुसार प्रदर्शन, जो दिखाता है कि आपका मॉडल अलग-अलग क्लासों की कितनी अच्छी पहचान करता है; 4. एक confusion matrix, जिसका उपयोग आप उन विशिष्ट क्लासों को खोजने के लिए कर सकते हैं जिनमें आपका मॉडल अच्छा करता है और जिनमें उसे कठिनाई होती है, और; 5. एक इंटरैक्टिव vector explorer, जो आपको उन इमेज क्लस्टरों की पहचान करने देता है जहाँ आपका मॉडल अच्छा या खराब प्रदर्शन करता है; आप अपने मॉडल के सुधार योग्य क्षेत्रों की पहचान करने के लिए model evaluation का उपयोग कर सकते हैं। मूल्य सशुल्क उपयोगकर्ताओं द्वारा Roboflow पर प्रशिक्षित या अपलोड किए गए सभी versioned models के लिए स्वचालित रूप से चलाए जाते हैं। कुछ सौ इमेज वाले dataset के लिए evaluation चलने में कई मिनट लग सकते हैं, और हजारों या अधिक इमेज वाले बड़े datasets के लिए कई घंटे लग सकते हैं। ### इन्फरेंस के लिए अनुकूलन ट्रेनिंग के बाद, Roboflow आपके model को उस package में compile करता है जिसे Serverless Cloud API सर्व करता है। जब यह प्रक्रिया चल रही होती है, model पर "इन्फरेंस के लिए अनुकूलन" दिखता है, और evaluation इसके पूरा होने तक प्रतीक्षा करता है। इस तरह evaluation वही package मापता है जो आपकी inference requests को सर्व करता है। Compilation में आमतौर पर कुछ मिनट जुड़ जाते हैं। अगर यह विफल हो जाए, या 24 घंटे से अधिक लग जाएँ, तो evaluation फिर भी शुरू हो जाता है। ### समर्थित प्रोजेक्ट प्रकार Model evaluation Object Detection, Instance Segmentation, Classification, और Semantic Segmentation projects को सपोर्ट करता है। सेमांटिक सेगमेंटेशन के लिए, मुख्य मेट्रिक है **mIoU** (mean Intersection-over-Union) mAP के बजाय। सभी मेट्रिक्स (precision, recall, F1) प्रति-instance के बजाय pixel-level पर गणना किए जाते हैं। per-class breakdown प्रत्येक class के लिए IoU, precision, recall, F1, और एक optimal confidence threshold दिखाता है। Confusion matrix के मान object counts के बजाय pixel counts को दर्शाते हैं। ## वेब ऐप ### Model Evaluation खोलें अपने model के लिए confusion matrix और vector explorer खोजने के लिए, अपने project में कोई भी trained model खोलें। फिर, "View Evaluation" बटन पर क्लिक करें:
एक विंडो खुलेगी जहाँ आप अपनी confusion matrix और vector analysis देख सकते हैं। ### मध्य लेटेंसी यह evaluation Serverless Cloud API को एक request का उत्तर देने में लगने वाले median समय को दिखाता है, जिसे आपकी test images पर मापा गया है। इस मान में preprocessing और postprocessing समय शामिल है। इसमें network time शामिल नहीं है। आपके model lists और model cards में यही मान "Latency (Cloud API)" के रूप में दिखता है। एक से लेटेंसी [Neural Architecture Search](/models/hi/train/neural-architecture-search.md) benchmark को एक अलग तरीके से मापा जाता है, इसलिए दोनों की तुलना न करें। यदि आपकी test images में model input के मुकाबले कम-से-कम दोगुने pixels हैं, तो evaluation capture resolution के बारे में एक सिफारिश जोड़ता है। सर्वर model चलाने से पहले हर image को decode और resize करता है, इसलिए जिन frames का लंबा side model input के करीब होता है, वे तेज़ उत्तर देते हैं। ### प्रोडक्शन मेट्रिक्स एक्सप्लोरर प्रोडक्शन मेट्रिक्स एक्सप्लोरर आपके model के लिए सभी संभव confidence thresholds पर Precision, Recall, और F1 score दिखाता है। यह जानकारी एक graph पर प्रस्तुत की जाती है। इन आँकड़ों का उपयोग करके, प्रोडक्शन मेट्रिक्स एक्सप्लोरर एक "optimal confidence" की सिफारिश करेगा। यह वह threshold है जो आपको Precision/Recall/F1 Score का सबसे अच्छा संतुलन देगा। एक बार model evaluation पूरा हो जाने पर, optimal confidence threshold अपने-आप आपके model के inference requests के लिए default के रूप में लागू हो जाता है। यदि per-class thresholds उपलब्ध हैं, तो वे भी लागू होते हैं, और किसी भी class के लिए जिसका अपना मान नहीं है, global threshold fallback के रूप में उपयोग होता है। आप किसी भी individual inference request पर confidence threshold को अभी भी ओवरराइड कर सकते हैं, यह पास करके `confidence` parameter को स्पष्ट रूप से।
आप slider को खींचकर अलग-अलग confidence thresholds पर F1/Precision/Recall मान देख सकते हैं:
### मॉडल सुधार सिफारिशें आपके model evaluation का मॉडल सुधार सिफारिशें अनुभाग बताता है कि आप अपने model की सटीकता कैसे बढ़ा सकते हैं। ये सुधार आपके model के साथ गणना किए गए confusion matrix के परिणामों पर आधारित होते हैं। (इस पृष्ठ पर आगे अपने confusion matrix के बारे में अधिक जानकारी देखें)। मॉडल सुधार सिफारिशें फीचर निम्न से संबंधित सुझाव दे सकता है: * ऐसे model को कैसे सुधारा जाए जो बहुत सारे false negatives predict करता है। * ऐसे model को कैसे सुधारा जाए जो बहुत सारे false positives predict करता है। * कौन-सी classes अक्सर confuse (गलत पहचानी) जाती हैं। * कौन-सी classes को accuracy बढ़ाने के लिए अधिक data चाहिए। * जब test या validation set बहुत छोटा हो सकता है। * और भी बहुत कुछ।
### क्लास के अनुसार प्रदर्शन क्लास के अनुसार प्रदर्शन चार्ट दिखाता है कि आपके dataset की सभी classes में कितनी correct predictions, misclassifications, false negatives, और false positives हैं। आप इस जानकारी का उपयोग एक नज़र में यह देखने के लिए कर सकते हैं कि आपका model किन classes की अच्छी पहचान कर सकता है और किन classes की पहचान करने में हमारा model संघर्ष करता है।
यदि आपके dataset में classes की संख्या बहुत अधिक है, तो आप "All Classes" dropdown खोलकर और जिन classes को आप highlight करना चाहते हैं उन्हें चुनकर chart को विशिष्ट classes पर केंद्रित कर सकते हैं:
आप Confidence Threshold slider को हिलाकर यह भी देख सकते हैं कि अलग-अलग confidence thresholds पर यह chart कैसे बदलता है:
डिफ़ॉल्ट रूप से, यह chart उस optimal confidence threshold का उपयोग करेगा जिसकी हम सिफारिश करते हैं। ### Confusion Matrix आपकी confusion matrix दिखाती है कि आपका model अलग-अलग classes पर कितना अच्छा प्रदर्शन करता है। आपकी confusion matrix आपके trained model के साथ आपकी test और validation sets की images चलाकर गणना की जाती है। फिर आपके model के परिणामों की तुलना आपके dataset annotations के "ground truth" से की जाती है। confusion matrix tool के साथ, आप पहचान सकते हैं: * वे classes जहाँ आपका model अच्छा प्रदर्शन करता है। * वे classes जहाँ आपका model किसी object के लिए गलत class पहचानता है (false positives)। * वे instances जहाँ आपका model किसी object की पहचान करता है जबकि ground truth में वहाँ कोई object मौजूद नहीं होता (false negatives)। यहाँ confusion matrix का एक उदाहरण है:
यदि आपका model कई classes detect करता है, तो scroll bars दिखाई देंगी जो आपको confusion matrix में नेविगेट करने देती हैं। डिफ़ॉल्ट रूप से, confusion matrix दिखाती है कि आपका model उसके लिए गणना किए गए optimal threshold पर चलाने पर कैसा प्रदर्शन करता है। आप Confidence Threshold slider का उपयोग करके confidence threshold को समायोजित कर सकते हैं। जैसे-जैसे आप slider configure करते हैं, आपकी confusion matrix, precision, और recall अपडेट होंगे:
आप confusion matrix में हर box पर क्लिक करके देख सकते हैं कि संबंधित category में कौन-सी images आती हैं। उदाहरण के लिए, आप "False Positive" column में किसी भी box पर क्लिक करके उन images की पहचान कर सकते हैं जहाँ ground truth data में object मौजूद नहीं था, फिर भी उसकी पहचान की गई थी।
आप किसी individual image पर क्लिक करके एक interactive view में प्रवेश कर सकते हैं जहाँ आप ground truth (आपके annotations) और model predictions के बीच toggle कर सकते हैं:
अपने annotations देखने के लिए "Ground Truth" पर क्लिक करें और आपका model क्या लौटाता है यह देखने के लिए "Model Predictions" पर क्लिक करें। ## HTTP API एक model evaluation यह कैप्चर करता है कि version के test split पर model कैसा प्रदर्शन करता है - per-class metrics, confidence-threshold curves, image-embedding clustering, per-image predictions, और improvement recommendations। object detection और instance segmentation के लिए मुख्य मेट्रिक mAP है; semantic segmentation के लिए यह mIoU है। Training पूरी होने पर evaluations अपने-आप बनाए जाते हैं और ऐप से मैन्युअल रूप से फिर से शुरू किए जा सकते हैं। Model Evaluations API आपको वह सब कुछ पढ़ने देती है जो app का evaluation page दिखाता है। UI का हर panel एक समर्पित endpoint से mapped है: * [किसी workspace में model evaluations की सूची बनाएं](#list-model-evaluations) * [एक evaluation का metadata और मुख्य मेट्रिक्स प्राप्त करें](#get-a-model-evaluation) * [पूर्ण per-split metric विवरण प्राप्त करें (mAP या mIoU)](#map-results) * [confidence-threshold sweep और F1-optimal thresholds प्राप्त करें](#confidence-sweep) * [एक split के लिए per-class प्रदर्शन प्राप्त करें](#performance-by-class-1) * [confusion matrix प्राप्त करें](#confusion-matrix-1) * [image-embedding clustering (vector analysis) प्राप्त करें](#vector-analysis) * [per-image predictions प्राप्त करें](#per-image-predictions) * [model सुधार सिफारिशें प्राप्त करें](#recommendations) ### प्रमाणीकरण सभी endpoints के लिए निम्न के साथ एक API key आवश्यक है `model-eval:read` scope। इसे query parameter के रूप में या `Bearer` token के रूप में `Authorization` header में पास करें। ### सामान्य त्रुटियाँ | स्थिति | त्रुटि कोड | कब | | ------ | ---------------------- | --------------------------------------------------------------------- | | `401` | अप्रमाणित | API key अनुपस्थित या अमान्य | | `404` | `model_eval_not_found` | Evaluation मौजूद नहीं है या किसी अलग workspace का हिस्सा है | | `409` | `model_eval_not_done` | Evaluation पूरा नहीं हुआ है; panel data अभी उपलब्ध नहीं है | | `400` | `invalid_confidence` | `confidence` query parameter एक integer नहीं है in `[0, 100]` | | `400` | `invalid_split` | `split` query parameter endpoint के लिए अनुमत मानों में से एक नहीं है | ### Model Evaluations सूचीबद्ध करें किसी workspace में model evaluations की सूची बनाएं। यह एक संक्षिप्त प्रोजेक्शन लौटाता है - किसी विशिष्ट evaluation के मुख्य मेट्रिक्स के लिए आगे यह करें [एक Model Evaluation प्राप्त करें](#get-a-model-evaluation). ```url https://api.roboflow.com/:workspace/model-evals ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals?api_key=$ROBOFLOW_API_KEY&status=done&limit=10" ``` #### क्वेरी पैरामीटर | पैरामीटर | प्रकार | विवरण | | ----------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `project` | string | किसी project को उसके URL slug के आधार पर फ़िल्टर करें (उदा. `chess-pieces-fmhpz`) | | `version` (alias `versionId`) | string | किसी विशिष्ट version के लिए फ़िल्टर करें (उदा. `"4"`) | | `model` (alias `modelId`) | string | किसी model को उसके URL slug ID के आधार पर फ़िल्टर करें, workspace prefix के साथ या बिना (उदा. `my-workspace/chess-pieces-fmhpz-2` या `chess-pieces-fmhpz-2`) | | `status` | enum | इनमें से एक `pending`, `running`, `done`, `failed`. अज्ञात मान लौटाते हैं `400`. | | `limit` | integer | पृष्ठ आकार; डिफ़ॉल्ट `50`, अधिकतम `200` | अधिकतम इनमें से एक `project` / `version` / `model` प्रत्येक call में सेट किया जा सकता है (सबसे विशिष्ट वाला लागू होता है: `model` > `version` > `project`). संयोजन इस के साथ अस्वीकार किए जाते हैं `400 invalid_filter_combination` ताकि storage indices सीमित रहें। #### प्रतिक्रिया ```json { "evals": [ { "evalId": "huUF720inUcymARwqAGK", "status": "done", "project": "chess-pieces-fmhpz", "versionId": "4", "modelId": "my-workspace/chess-pieces-fmhpz-2", "createdAt": "2026-04-27T20:04:10.904Z", "medianLatencyMs": 11.9 } ] } ``` `project` यह परियोजना का URL slug है - वही पहचानकर्ता जिसे REST API URL paths में उपयोग करती है (`/:workspace/:project/...`). evaluation UI के लिए deep-link बनाने हेतु: `https://app.roboflow.com/{workspace}/{project}/evaluation/{versionId}`. `modelId` यह model का URL slug ID है, वही ID जिसे आप models और inference endpoints को पास करते हैं, ताकि आप strings की तुलना करके evaluation को उसके model से मिला सकें। जो evaluations एक single model के बजाय version पर चले थे, वे रिपोर्ट करते हैं `{project}/{versionId}` के बजाय। `medianLatencyMs` Serverless Cloud API का मध्य सर्वर-साइड समय है, मिलीसेकंड में। यह `null` जब evaluation ने इसे मापा नहीं। ### एक Model Evaluation प्राप्त करें इसकी ID द्वारा एक single model evaluation प्राप्त करें। पूर्ण evaluations के लिए response में एक `summary` object जिसमें मुख्य मेट्रिक्स होते हैं; लंबित, चल रहे, और विफल evaluations केवल संक्षिप्त संरचना लौटाते हैं। कौन-सा मुख्य मेट्रिक भरा जाएगा यह task type पर निर्भर करता है - `mAP` डिटेक्शन-आकार वाले tasks के लिए, `mIoU` सेमांटिक सेगमेंटेशन के लिए। ```url https://api.roboflow.com/:workspace/model-evals/:evalId ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/huUF720inUcymARwqAGK?api_key=$ROBOFLOW_API_KEY" ``` #### प्रतिक्रिया (पूर्ण evaluation) ```json { "evalId": "huUF720inUcymARwqAGK", "status": "done", "project": "chess-pieces-fmhpz", "versionId": "4", "modelId": "my-workspace/chess-pieces-fmhpz-2", "createdAt": "2026-04-27T20:04:10.904Z", "summary": { "mAP": 0.9239650566041828, "mIoU": null, "precision": 0.85, "recall": 0.85, "medianLatencyMs": 11.9 } } ``` #### प्रतिक्रिया (लंबित, चल रहा, या विफल) वही फ़ील्ड्स बिना `summary` ब्लॉक के। ```json { "evalId": "fNyWx6PC74rCc18IuZ3M", "status": "running", "project": "hard-hat-detection", "versionId": "1", "modelId": "hard-hat-detection/1", "createdAt": "2026-03-19T21:02:07.918Z" } ``` #### नोट्स * `mAP` IoU 0.5 पर mean Average Precision है (`map50`)। यह `null` गैर-डिटेक्शन evaluation tasks (जैसे classification, semantic segmentation) के लिए। * `mIoU` foreground macro mean Intersection-over-Union है। यह केवल semantic segmentation evaluations में भरा जाता है और `null` अन्यथा null रहता है। * `precision` और `recall` test split के लिए F1-optimal confidence threshold पर रिपोर्ट किए जाते हैं। * `medianLatencyMs` Serverless Cloud API का मध्य सर्वर-साइड समय है, मिलीसेकंड में, 500 तक test-split images पर मापा गया। इसमें preprocessing और postprocessing समय शामिल है और network time शामिल नहीं है। यह `null` जब evaluation ने इसे मापा नहीं। * `status` है `pending` जब evaluation inference के लिए model के compile होने की प्रतीक्षा करता है। यह बदलकर `running` जब evaluation job शुरू होता है। * `evalId` हर panel response में अंतर्निहित वही identifier है - `modelEvals.get` payload संरचनात्मक रूप से किसी भी panel payload का superset है, इसलिए एक `summary`-से संवर्धित `modelEvals.get` और एक `getMapResults` response को उसी client code path से render किया जा सकता है। * `project` यह project का URL slug है - वही पहचानकर्ता जिसे REST API URL paths में उपयोग करती है। evaluation UI के लिए deep-link बनाने हेतु: `https://app.roboflow.com/{workspace}/{project}/evaluation/{versionId}`. `project` है `null` यदि project delete कर दिया गया है। * `modelId` यह model का URL slug ID है (`{workspace}/{model}`), या `{project}/{versionId}` किसी ऐसे evaluation के लिए जो एक single model के बजाय version पर चला था। यह `null` यदि model अब resolve नहीं हो सकता। ### Map Results evaluation के लिए प्राथमिक metric detail लौटाता है। response की संरचना task type पर निर्भर करती है: * **Object detection / instance segmentation** - IoU 0.5 / 0.5-0.95 / 0.75 पर प्रति split mAP, object size और per class के अनुसार विभाजित। * **Semantic segmentation** - mIoU, precision, recall, F1 (pixel-level) प्रति split, per-class IoU और optimal confidence thresholds के साथ। यह `taskType` फ़ील्ड response में बताता है कि किस संरचना की अपेक्षा करनी है: `"object-detection-like"` या `"semantic-segmentation"`. यह वही डेटा है जिसे **metrics per split** पैनल ऐप में पढ़ता है। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/map-results ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/map-results?api_key=$ROBOFLOW_API_KEY" ``` #### प्रतिक्रिया (object detection / instance segmentation) ```json { "taskType": "object-detection-like", "splits": { "test": { "map50": 0.9239650566041828, "map50_95": 0.7555258345429926, "map75": 0.9239650566041828, "byObjectSize": { "small": { "map50": 0.9038189533239035, "map50_95": 0.6478143732740621, "map75": 0.9038189533239035 }, "medium": { "map50": 0.9913366336633663, "map50_95": 0.8572608399609195, "map75": 0.9913366336633663 }, "large": null }, "perClass": { "Car-rims": { "map50": 0.9239650566041828, "map50_95": 0.7555258345429926, "map75": 0.9239650566041828, "byObjectSize": { "small": { "map50": 0.9, "map50_95": 0.65, "map75": 0.85 }, "medium": { "map50": 0.99, "map50_95": 0.85, "map75": 0.99 }, "large": null } } } }, "valid": { "...": "same shape" }, "train": { "...": "same shape" } } } ``` #### प्रतिक्रिया (semantic segmentation) ```json { "taskType": "semantic-segmentation", "splits": { "test": { "miou": 0.816, "precision": 0.938, "recall": 0.862, "f1": 0.898, "perClass": [ { "classID": 3, "className": "multi", "iou": 0.816, "precision": 0.938, "recall": 0.862, "f1": 0.898, "optimalThreshold": 0.0 } ] }, "valid": { "...": "same shape" }, "train": { "...": "same shape" } } } ``` #### नोट्स * यह `taskType` फ़ील्ड response संरचना को अलग करता है। split की सामग्री पार्स करने से पहले हमेशा इसे जांचें। * **डिटेक्शन:** `map50_95` 0.5 से 0.95 तक 0.05 के चरणों में IoU thresholds पर औसत mAP है (COCO मानक)। object-size buckets `null` जब split में उस आकार के कोई instances नहीं होते। Per-class entries `perClass`में nested को छोड़कर वही संरचना होती है * **Semantic segmentation:** सभी मेट्रिक्स foreground classes (background excluded) पर pixel-level macro means हैं। `miou` mean Intersection-over-Union है। `optimalThreshold` प्रति-क्लास F1-optimal confidence threshold है। इसका मान `0.0` मान्य है और इसका अर्थ है कि model argmax पर peak करता है। ### Confidence Sweep प्रति-confidence-threshold metric curves और प्रति split (और per class) F1-optimal threshold लौटाता है। precision/recall trade-offs को plot करने और deployment-time threshold चुनने के लिए उपयोगी। यह वही डेटा है जिसे **production metrics explorer** पैनल ऐप में पढ़ता है। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/confidence-sweep ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/confidence-sweep?api_key=$ROBOFLOW_API_KEY" ``` #### प्रतिक्रिया ```json { "splits": { "test": { "perThreshold": { "0.00": { "precision": 0.02, "recall": 1.0, "f1": 0.039 }, "0.20": { "precision": 0.45, "recall": 0.92, "f1": 0.605 }, "0.37": { "precision": 0.85, "recall": 0.85, "f1": 0.85 }, "0.50": { "precision": 0.91, "recall": 0.78, "f1": 0.84 } }, "optimalThreshold": 0.37, "optimalMetrics": { "precision": 0.85, "recall": 0.85, "f1": 0.85 }, "perClass": { "Car-rims": { "perThreshold": { "0.37": { "precision": 0.85, "recall": 0.85, "f1": 0.85 } }, "optimalThreshold": 0.37, "optimalMetrics": { "precision": 0.85, "recall": 0.85, "f1": 0.85 } } } }, "valid": { "...": "same shape" }, "train": { "...": "same shape" } } } ``` #### नोट्स * `perThreshold` कुंजियाँ decimal strings के रूप में confidence thresholds हैं, आम तौर पर हर `0.01` से `0.00` तक `0.99`. * `optimalThreshold` वह threshold है जो उस split के लिए F1 को अधिकतम करता है। * किसी split के अंदर per-class entries `perClass` में nested को छोड़कर वही संरचना होती है `perClass`. ### क्लास के अनुसार प्रदर्शन एक split के लिए per-class मुख्य मेट्रिक्स लौटाता है। response की संरचना evaluation के task type पर निर्भर करती है: * **Object detection / instance segmentation** - per-class `map50`, `map50_95`, `map75`, precision, recall, F1, और इष्टतम थ्रेशहोल्ड। * **Semantic segmentation** - per-class `iou`, precision, recall, F1, और इष्टतम थ्रेशहोल्ड (पिक्सेल-स्तर)। यह `taskType` प्रतिक्रिया में फ़ील्ड बताता है कि किस आकार की अपेक्षा करनी है। यह वही डेटा है जिसे **क्लास-वार प्रदर्शन** पैनल ऐप में पढ़ता है। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/performance-by-class ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/performance-by-class?api_key=$ROBOFLOW_API_KEY&split=test" ``` #### क्वेरी पैरामीटर | पैरामीटर | प्रकार | विवरण | | -------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `split` | enum | इनमें से एक `train`, `valid`, `test`. डिफ़ॉल्ट `test`. `all` है **नहीं** यहाँ valid है - प्रति-क्लास मेट्रिक्स को विभाजनों के पार एकत्रित नहीं किया जा सकता। | #### प्रतिक्रिया (object detection / instance segmentation) ```json { "taskType": "object-detection-like", "split": "test", "classes": [ { "className": "Car-rims", "map50": 0.9239650566041828, "map50_95": 0.7555258345429926, "map75": 0.9239650566041828, "precision": 0.85, "recall": 0.85, "f1": 0.85, "optimalThreshold": 0.37 }, { "className": "music-note", "map50": null, "map50_95": null, "map75": null, "precision": 0, "recall": 0, "f1": 0, "optimalThreshold": 0.5 } ] } ``` #### प्रतिक्रिया (semantic segmentation) ```json { "taskType": "semantic-segmentation", "split": "test", "classes": [ { "classID": 3, "className": "multi", "iou": 0.816, "precision": 0.938, "recall": 0.862, "f1": 0.898, "optimalThreshold": 0.0 } ] } ``` #### नोट्स * `taskType` प्रति-क्लास फ़ील्ड सेट को अलग करता है। डिटेक्शन क्लासेज़ में शामिल हैं `map50`/`map50_95`/`map75`; सेमांटिक सेगमेंटेशन क्लासेज़ में शामिल हैं `iou` और `classID` के बजाय। * `optimalThreshold` confidence sweep से प्राप्त प्रति-क्लास F1-इष्टतम confidence threshold है। * `precision`, `recall`, और `f1` उस प्रति-क्लास इष्टतम थ्रेशहोल्ड पर रिपोर्ट किए जाते हैं। * डिटेक्शन के लिए, mAP फ़ील्ड हैं `null` जब उस split में उस class के कोई instances नहीं होते। * सेमांटिक सेगमेंटेशन के लिए, सभी मेट्रिक्स पिक्सेल-स्तर के हैं। एक `optimalThreshold` का `0.0` मान्य है। ### Confusion Matrix प्रति-छवि भविष्यवाणियों से निकाला गया समेकित कन्फ्यूज़न मैट्रिक्स लौटाता है। प्रत्येक सेल `matrix[actual][predicted]` उन instances की संख्या है जहाँ ground-truth class थी `actual` और मॉडल ने अनुमान लगाया `predicted`। सेमांटिक सेगमेंटेशन मूल्यांकनों के लिए, मान instance counts के बजाय pixel counts दर्शाते हैं। यह वही डेटा है जिसे **कन्फ्यूज़न मैट्रिक्स** पैनल ऐप में पढ़ता है। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/confusion-matrix ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/confusion-matrix?api_key=$ROBOFLOW_API_KEY&split=test" ``` #### क्वेरी पैरामीटर | पैरामीटर | प्रकार | विवरण | | ------------ | ------- | --------------------------------------------------------------------------------------------- | | `split` | enum | इनमें से एक `train`, `valid`, `test`, या `all`. डिफ़ॉल्ट `test`. | | `confidence` | integer | में Confidence-threshold प्रतिशत `[0, 100]`. डिफ़ॉल्ट रूप से canonical फ़ाइल (आमतौर पर `20`). | #### प्रतिक्रिया ```json { "split": "test", "confidenceThreshold": 0.2, "classes": ["Car-rims", "music-note", "background"], "matrix": [ [20, 0, 0], [ 0, 0, 0], [80, 0, 0] ] } ``` उपरोक्त उदाहरण में, confidence threshold 0.2 पर: * के सभी 20 instances `Car-rims` सही रूप से वर्गीकृत किए गए (`matrix[0][0] = 20`) * मॉडल ने 80 false positives उत्पन्न किए - अनुमान लगाया `Car-rims` जब वास्तविक class थी `background` (`matrix[2][0] = 80`) * test split में कोई नहीं है `music-note` उदाहरण #### नोट्स * `confidence` यह चुनता है कि रिपोर्ट के किस अंतर्निहित per-confidence variant को एकत्रित करना है। अलग-अलग thresholds अलग-अलग matrices देती हैं। * `split=all` train, valid और test के raw counts को एकत्रित करता है। ### वेक्टर विश्लेषण मूल्यांकन के लिए image-embedding clustering output लौटाता है - UMAP-projected embeddings को HDBSCAN द्वारा क्लस्टर किया गया है, साथ में प्रति-क्लस्टर समेकित मेट्रिक्स। यह उन छवियों के समूहों को पहचानने में उपयोगी है जहाँ मॉडल व्यवस्थित रूप से बेहतर या खराब प्रदर्शन करता है। यह वही डेटा है जिसे **वेक्टर विश्लेषण** पैनल ऐप में पढ़ता है। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/vector-analysis ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/vector-analysis?api_key=$ROBOFLOW_API_KEY" ``` #### क्वेरी पैरामीटर | पैरामीटर | प्रकार | विवरण | | ------------ | ------- | ----------------------------------------------------------------------------------- | | `confidence` | integer | में Confidence-threshold प्रतिशत `[0, 100]` (canonical report पर डिफ़ॉल्ट होता है)। | #### प्रतिक्रिया ```json { "clustering": { "method": "hdbscan", "nClusters": 54, "metrics": { "noiseRatio": 0.078125, "silhouetteScore": 0.48925095796585083 }, "parameters": { "min_cluster_size": 2, "min_samples": 1, "cluster_selection_method": "eom", "metric": "euclidean" }, "processingTimeSeconds": 8.36 }, "preprocessing": { "method": "umap", "originalDimensions": 768, "targetDimensions": 10, "nNeighbors": 30, "minDistance": 0.05 }, "clusters": [ { "id": -1, "numImages": 15, "splitDistribution": { "train": 12, "valid": 2, "test": 1 }, "metrics": { "f1Mean": 0.462, "f1Std": 0.219, "f1Min": 0.129, "f1Max": 0.8, "precisionMean": 0.330, "recallMean": 0.952 }, "sampleImages": ["img1.jpg", "img2.jpg"] }, { "id": 0, "numImages": 3, "splitDistribution": { "train": 2, "valid": 1 }, "metrics": { "f1Mean": 0.889, "f1Std": 0.157, "f1Min": 0.667, "f1Max": 1.0, "precisionMean": 1.0, "recallMean": 0.833 }, "sampleImages": ["img3.jpg", "img4.jpg", "img5.jpg"] } ] } ``` #### नोट्स * क्लस्टर आईडी `-1` शोर/अक्लस्टर्ड बकेट (HDBSCAN convention) है - ऐसी images जो किसी भी सघन क्षेत्र में फिट नहीं होतीं। * `precisionMean` और `recallMean` क्लस्टर की सभी images पर औसत किए जाते हैं। * प्रति-छवि embeddings और cluster assignments इसके माध्यम से उपलब्ध कराए जाते हैं [प्रति-छवि भविष्यवाणियाँ](#per-image-predictions). ### प्रति-छवि भविष्यवाणियाँ प्रति-छवि prediction records लौटाता है - TP/FP/FN counts, प्रति-छवि precision/recall/F1, छवि का cluster id और 2D embedding, तथा raw confusion entries। पेजिनेटेड। यह वही डेटा है जिसे **प्रति-छवि भविष्यवाणियाँ** पैनल ऐप में पढ़ता है। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/image-predictions ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/image-predictions?api_key=$ROBOFLOW_API_KEY&split=test&limit=50" ``` #### क्वेरी पैरामीटर | पैरामीटर | प्रकार | विवरण | | ------------ | ------- | ----------------------------------------------------------------------------------------------------------- | | `split` | enum | इनमें से एक `train`, `valid`, `test`, या `all`. डिफ़ॉल्ट `all`. | | `confidence` | integer | में Confidence-threshold प्रतिशत `[0, 100]` (यह चुनता है कि कौन-सा per-confidence report variant पढ़ना है)। | | `limit` | integer | पृष्ठ आकार; डिफ़ॉल्ट `200`, अधिकतम `1000`. | | `offset` | integer | लौटाने से पहले इतनी records छोड़ें। डिफ़ॉल्ट `0`. | #### प्रतिक्रिया ```json { "split": "test", "confidenceThreshold": 0.2, "totalImages": 192, "offset": 0, "limit": 50, "images": [ { "imageId": "1QKLCUsfAzFiCIb6YCJj", "imageName": "abc.jpg", "split": "test", "augmentations": 2, "cluster": { "id": 4, "embedding2D": [7.494518280029297, -5.143994331359863] }, "stats": { "truePositives": 2, "falsePositives": 7, "falseNegatives": 0, "precision": 0.222, "recall": 1.0, "f1": 0.364 }, "confusion": [ [0, 0, 2], [2, 0, 7] ] } ] } ``` #### नोट्स * `imageId` Roboflow source image id है - अन्य Roboflow APIs के साथ cross-referencing के लिए उपयोगी। * `confusion` entries होते हैं `[actualClassIdx, predictedClassIdx, count]` त्रय; class indices उसी array को संदर्भित करते हैं जो [Confusion Matrix](#confusion-matrix-1)'s `classes`. * `embedding2D` UMAP-projected 2D coordinate है जिसका उपयोग [वेक्टर विश्लेषण](#vector-analysis) plot में होता है। * विभिन्न `confidence` मान अलग-अलग stats लौटाते हैं - predictions threshold के साथ बदलती हैं। ध्यान दें कि मनमाने `confidence` मान केवल उन thresholds के लिए सफल होंगे जिन्हें eval pipeline ने materialized किया है; unmaterialized variants लौटाते हैं `404 report_not_found`. * **पेजिनेशन लागत**: प्रत्येक पेज पूरी `model_eval_results.json` फ़ाइल को storage से फिर से पढ़ता है और server-side पर slice करता है। बहुत बड़े `image_results` arrays के लिए, अधिक बड़े `limit` मान (तक `1000`) को कई छोटे pages के बजाय प्राथमिकता दें ताकि प्रति-पेज निश्चित लागत कम हो। ### सिफारिशें पूर्ण मूल्यांकन से उत्पन्न मॉडल सुधार सिफारिशें लौटाता है - class-imbalance चेतावनियाँ, missed-detection पैटर्न, और आपके dataset में क्या जोड़ना है या कैसे पुनः प्रशिक्षण देना है, इस बारे में अन्य actionable सुझाव। यह वही डेटा है जिसे **मॉडल सुधार सिफारिशें** पैनल ऐप में पढ़ता है। यह endpoint **केवल-पठन**. सिफारिशें training completion के side effect के रूप में (या legacy in-app "Refresh Recommendations" action के माध्यम से) उत्पन्न होती हैं। यदि वे अभी तक उत्पन्न नहीं हुई हैं, तो प्रतिक्रिया है `200 {"generated": false}` - ध्यान दें कि यह **नहीं** एक `409 EVAL_NOT_DONE`. मूल्यांकन *है* समाप्त; इसमें केवल वैकल्पिक recommendations side-output नहीं है। अन्य panel endpoints (`map-results`, `confidence-sweep`, आदि) लौटाते हैं `409 EVAL_NOT_DONE` जब उनका backing data अनुपलब्ध होता है, क्योंकि वह डेटा मूल्यांकन का अभिन्न हिस्सा है; recommendations नहीं हैं। ```url https://api.roboflow.com/:workspace/model-evals/:evalId/recommendations ``` ```bash curl "https://api.roboflow.com/my-workspace/model-evals/$EVAL_ID/recommendations?api_key=$ROBOFLOW_API_KEY" ``` #### प्रतिक्रिया (सिफारिशें उपलब्ध हैं) ```json { "generated": true, "generatedAt": "2026-04-27T20:05:37.512Z", "recommendations": { "summary": { "confidenceThreshold": 37, "split": "test", "generatedAt": "2026-04-27T20:05:37.512Z", "count": 3, "f1": 0.85, "precision": 0.85, "recall": 0.85 }, "items": [ { "id": "56bcd423-38ff-45f9-b3e0-662a71ce44e6", "type": "missed_detection", "analysis": { "affected_class": "Car-rims", "count": 3 } }, { "id": "150e49a8-3a61-479a-9e18-3eb751494a70", "type": "class_imbalance", "analysis": { "affected_class": "Car-rims", "current_count": 20, "total_gt_instances": 20, "median_count": 10 } } ] } } ``` #### प्रतिक्रिया (अभी तक उत्पन्न नहीं हुई) ```json { "generated": false } ``` ## MCP सर्वर अपने AI agent को इससे जोड़ें [MCP सर्वर](https://docs.roboflow.com/agents/mcp-server) और यह इन tools के साथ देख सकता है कि मॉडल ने कैसा प्रदर्शन किया:
टूलविवरण
model_evals_listवर्कस्पेस में model evaluations सूचीबद्ध करें।
model_evals_getएक evaluation का शीर्ष-स्तरीय सारांश प्राप्त करें।
model_evals_get_map_resultsप्रति-split mAP परिणाम प्राप्त करें।
model_evals_get_confusion_matrixकन्फ्यूज़न मैट्रिक्स प्राप्त करें।
model_evals_get_performance_by_classएक split के लिए प्रति-क्लास प्रदर्शन मेट्रिक्स प्राप्त करें।
model_evals_get_recommendationsयदि उपलब्ध हों, तो मूल्यांकन के लिए उत्पन्न सिफारिशें प्राप्त करें।