> 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, जो आपको उन छवियों के समूहों की पहचान करने देता है जहाँ आपका मॉडल अच्छा या खराब प्रदर्शन करता है; आप अपने मॉडल के सुधार योग्य क्षेत्रों की पहचान करने के लिए मॉडल मूल्यांकन का उपयोग कर सकते हैं. मॉडल मूल्यांकन स्वचालित रूप से सभी versioned models के लिए चलाए जाते हैं जिन्हें भुगतान करने वाले उपयोगकर्ताओं द्वारा Roboflow पर प्रशिक्षित किया गया है या अपलोड किया गया है. कुछ सौ छवियों वाले dataset के लिए मूल्यांकन चलने में कई मिनट लग सकते हैं, और हजारों या उससे अधिक छवियों वाले बड़े datasets के लिए कई घंटे लग सकते हैं. ### Inference के लिए अनुकूलन प्रशिक्षण के बाद, Roboflow आपके मॉडल को उस package में संकलित करता है जिसे Serverless Cloud API सर्व करता है. यह चलने के दौरान मॉडल "Inference के लिए अनुकूलित हो रहा है" दिखाता है, और मूल्यांकन इसके पूरा होने का इंतजार करता है. इस तरह मूल्यांकन उसी package को मापता है जो आपकी inference requests को सर्व करता है. Compilation में आमतौर पर कुछ मिनट अतिरिक्त लगते हैं. यदि यह विफल हो जाता है, या 24 घंटे से अधिक लगते हैं, तो मूल्यांकन फिर भी शुरू हो जाता है. ### समर्थित प्रोजेक्ट प्रकार मॉडल मूल्यांकन Object Detection, Instance Segmentation, Classification, और Semantic Segmentation प्रोजेक्ट्स का समर्थन करता है. Semantic Segmentation के लिए, मुख्य मेट्रिक है **mIoU** (mean Intersection-over-Union), mAP के बजाय. सभी मेट्रिक्स (precision, recall, F1) प्रति-इंस्टेंस के बजाय pixel स्तर पर गणना किए जाते हैं. प्रति-क्लास विवरण IoU, precision, recall, F1, और प्रत्येक क्लास के लिए एक इष्टतम confidence threshold दिखाता है. Confusion matrix के मान object counts के बजाय pixel counts का प्रतिनिधित्व करते हैं. ## वेब ऐप ### मॉडल मूल्यांकन खोलें अपने मॉडल के लिए confusion matrix और vector explorer खोजने के लिए, अपने प्रोजेक्ट में कोई भी प्रशिक्षित मॉडल खोलें. फिर, "मूल्यांकन देखें" बटन पर क्लिक करें:
एक विंडो खुलेगी जहाँ आप अपनी confusion matrix और vector analysis देख सकते हैं. ### मध्य विलंबता मूल्यांकन दिखाता है कि Serverless Cloud API को एक अनुरोध का उत्तर देने में लगने वाला मध्य समय, आपके test images पर मापा गया. इस मान में preprocessing और postprocessing समय शामिल है. इसमें नेटवर्क समय शामिल नहीं है. आपकी model lists और model cards वही मान "Latency (Cloud API)" के रूप में दिखाते हैं. एक से latency [न्यूरल आर्किटेक्चर सर्च](/models/hi/train/neural-architecture-search.md) benchmark को अलग तरीके से मापा जाता है, इसलिए दोनों की तुलना न करें. यदि आपकी test images में model input से कम से कम दोगुने pixels हैं, तो मूल्यांकन capture resolution के बारे में एक सिफारिश जोड़ता है. सर्वर मॉडल चलाने से पहले हर image को decode और resize करता है, इसलिए जिन frames का लंबा किनारा model input के करीब है, वे तेज़ उत्तर देते हैं. उपयोग करें [मॉडल तुलना](/models/hi/evaluate/compare-trained-models.md) एक ही Dataset Version पर models की test-set accuracy और latency की तुलना करने के लिए. ### प्रोडक्शन मेट्रिक्स एक्सप्लोरर प्रोडक्शन मेट्रिक्स एक्सप्लोरर आपके मॉडल के लिए सभी संभव confidence thresholds पर Precision, Recall, और F1 score दिखाता है. यह जानकारी एक ग्राफ पर प्रस्तुत की जाती है. इन आंकड़ों का उपयोग करके, production metrics explorer एक "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` पैरामीटर को स्पष्ट रूप से पास करके.
आप slider को खींचकर विभिन्न confidence thresholds पर F1/Precision/Recall मान देख सकते हैं:
### मॉडल सुधार सिफारिशें आपके model evaluation का model improvement recommendations अनुभाग आपके मॉडल की सटीकता बढ़ाने के तरीकों का सुझाव देता है. ये सुधार आपके मॉडल से गणना किए गए confusion matrix के परिणामों पर आधारित हैं. (इस पेज पर आगे अपने confusion matrix के बारे में अधिक जानकारी देखें). model improvement recommendations फ़ीचर निम्न से संबंधित सुझाव दे सकता है: * एक ऐसे मॉडल को कैसे बेहतर करें जो बहुत सारे false negatives की भविष्यवाणी करता है. * एक ऐसे मॉडल को कैसे बेहतर करें जो बहुत सारे false positives की भविष्यवाणी करता है. * कौन-सी classes अक्सर भ्रमित (गलत पहचानी) जाती हैं. * कौन-सी classes को सटीकता सुधारने के लिए अधिक डेटा की आवश्यकता है. * जब test या validation set बहुत छोटा हो सकता है. * और भी बहुत कुछ.
### क्लास के अनुसार प्रदर्शन क्लास के अनुसार प्रदर्शन चार्ट दिखाता है कि आपके dataset की सभी classes में कितनी सही भविष्यवाणियाँ, गलत वर्गीकरण, false negatives, और false positives हैं. आप इस जानकारी का उपयोग एक नज़र में यह देखने के लिए कर सकते हैं कि आपका मॉडल किन classes को अच्छी तरह पहचान सकता है और किन classes को पहचानने में उसे कठिनाई होती है.
यदि आपके dataset में classes की संख्या बहुत अधिक है, तो आप "All Classes" dropdown खोलकर और जिन classes को आप highlight करना चाहते हैं उन्हें चुनकर चार्ट को विशिष्ट classes पर केंद्रित कर सकते हैं:
Confidence Threshold slider को हिलाकर आप यह भी देख सकते हैं कि अलग-अलग confidence thresholds पर यह चार्ट कैसे बदलता है:
डिफ़ॉल्ट रूप से, यह चार्ट हमारे द्वारा सुझाए गए optimal confidence threshold का उपयोग करेगा. ### Confusion Matrix आपका confusion matrix दिखाता है कि आपका मॉडल विभिन्न classes पर कितनी अच्छी तरह प्रदर्शन करता है. आपका confusion matrix आपके प्रशिक्षित मॉडल के साथ आपके test और validation sets की images चलाकर गणना किया जाता है. फिर आपके मॉडल के परिणामों की तुलना आपके dataset annotations के "ground truth" से की जाती है. confusion matrix टूल के साथ, आप पहचान सकते हैं: * वे classes जहाँ आपका मॉडल अच्छा प्रदर्शन करता है. * वे classes जहाँ आपका मॉडल किसी object के लिए गलत class पहचानता है (false positives). * वे instances जहाँ आपका मॉडल ऐसा object पहचानता है जो मौजूद नहीं है (false negatives). यहाँ एक उदाहरण confusion matrix है:
यदि आपका मॉडल कई classes का पता लगाता है, तो scroll bars दिखाई देंगे जो आपको अपने confusion matrix में नेविगेट करने देते हैं. डिफ़ॉल्ट रूप से, confusion matrix दिखाता है कि आपका मॉडल तब कैसा प्रदर्शन करता है जब उसे आपके मॉडल के लिए गणना किए गए optimal threshold पर चलाया जाता है. आप Confidence Threshold slider का उपयोग करके confidence threshold समायोजित कर सकते हैं. जैसे-जैसे आप slider कॉन्फ़िगर करते हैं, आपकी confusion matrix, precision, और recall अपडेट हो जाएंगे:
आप confusion matrix में प्रत्येक box पर क्लिक करके देख सकते हैं कि संबंधित category में कौन-सी images दिखाई देती हैं. उदाहरण के लिए, आप "False Positive" column में किसी भी box पर क्लिक करके उन images की पहचान कर सकते हैं जहाँ ground truth डेटा में object मौजूद नहीं था, फिर भी उसे पहचान लिया गया.
आप किसी individual image पर क्लिक करके एक interactive view में प्रवेश कर सकते हैं जहाँ आप ground truth (आपके annotations) और model predictions के बीच toggle कर सकते हैं:
"Ground Truth" पर क्लिक करके अपने annotations देखें और "Model Predictions" पर क्लिक करके देखें कि आपके मॉडल ने क्या लौटाया. ## HTTP API एक model evaluation यह कैप्चर करता है कि एक model, Version के test split पर कैसा प्रदर्शन करता है - per-class metrics, confidence-threshold curves, image-embedding clustering, per-image predictions, और improvement recommendations. object detection और instance segmentation के लिए मुख्य मेट्रिक mAP है; semantic segmentation के लिए यह mIoU है. training पूरी होने पर evaluations स्वचालित रूप से उत्पन्न होते हैं और app से manual रूप से फिर से ट्रिगर किए जा सकते हैं. Model Evaluations API आपको ऐप के evaluation page पर दिखाई देने वाली हर चीज़ पढ़ने देता है. UI का प्रत्येक panel एक समर्पित endpoint से मैप होता है: * [एक workspace में model evaluations सूचीबद्ध करें](#list-model-evaluations) * [एक evaluation का metadata और headline metrics प्राप्त करें](#get-a-model-evaluation) * [पूर्ण per-split metric विवरण प्राप्त करें (mAP या mIoU)](#map-results) * [confidence-threshold sweep और F1-optimal thresholds प्राप्त करें](#confidence-sweep) * [एक split के लिए per-class performance प्राप्त करें](#performance-by-class-1) * [confusion matrix प्राप्त करें](#confusion-matrix-1) * [image-embedding clustering (vector analysis) प्राप्त करें](#vector-analysis) * [per-image predictions प्राप्त करें](#per-image-predictions) * [model improvement recommendations प्राप्त करें](#recommendations) ### प्रमाणीकरण सभी endpoints को एक API key की आवश्यकता होती है जिसके पास `model-eval:read` scope हो. इसे query parameter के रूप में या `Bearer` token के रूप में `Authorization` header में पास करें. ### सामान्य त्रुटियाँ | स्थिति | त्रुटि कोड | जब | | ------ | ---------------------- | ----------------------------------------------------------------- | | `401` | अप्रमाणित | API key गायब है या अमान्य है | | `404` | `model_eval_not_found` | मूल्यांकन मौजूद नहीं है या किसी अन्य workspace से संबंधित है | | `409` | `model_eval_not_done` | मूल्यांकन पूरा नहीं हुआ है; panel data अभी उपलब्ध नहीं है | | `400` | `invalid_confidence` | `confidence` query parameter में पूर्णांक नहीं है `[0, 100]` | | `400` | `invalid_split` | `split` query parameter endpoint के अनुमत मानों में से एक नहीं है | ### मॉडल मूल्यांकन सूचीबद्ध करें एक workspace में model evaluations सूचीबद्ध करता है. एक हल्का projection लौटाता है - किसी विशिष्ट evaluation के headline metrics के लिए आगे देखें [एक मॉडल मूल्यांकन प्राप्त करें](#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` | स्ट्रिंग | अपने URL slug के आधार पर किसी project को फ़िल्टर करें (उदा. `chess-pieces-fmhpz`) | | `version` (उपनाम `versionId`) | स्ट्रिंग | किसी विशिष्ट version को फ़िल्टर करें (उदा. `"4"`) | | `model` (उपनाम `modelId`) | स्ट्रिंग | अपने URL slug ID के आधार पर किसी model को फ़िल्टर करें, workspace prefix के साथ या बिना (उदा. `my-workspace/chess-pieces-fmhpz-2` या `chess-pieces-fmhpz-2`) | | `status` | एनम | इनमें से एक `pending`, `running`, `done`, `failed`. अज्ञात मान लौटाते हैं `400`. | | `limit` | पूर्णांक | पृष्ठ आकार; डिफ़ॉल्ट `50`, अधिकतम `200` | अधिकतम एक `project` / `version` / `model` प्रति कॉल सेट किया जा सकता है (सबसे विशिष्ट जीतता है: `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/...`). मूल्यांकन UI से deep-link करने के लिए: `https://app.roboflow.com/{workspace}/{project}/evaluation/{versionId}`. `modelId` मॉडल का URL slug ID है, वही ID जिसे आप models और inference endpoints को पास करते हैं, इसलिए आप strings की तुलना करके किसी evaluation को उसके model से मिला सकते हैं. एक version पर चले evaluations, न कि एक single model पर, रिपोर्ट करते हैं `{project}/{versionId}` इसके बजाय. `medianLatencyMs` Serverless Cloud API के सर्वर-साइड समय का मध्य मान है, मिलीसेकंड में. यह `null` होता है जब मूल्यांकन ने इसे मापा नहीं. ### एक मॉडल मूल्यांकन प्राप्त करें उसके ID द्वारा एक single model evaluation प्राप्त करें. पूर्ण evaluations के लिए प्रतिक्रिया में एक `summary` object होता है जिसमें headline metrics होते हैं; pending, running, और failed evaluations केवल हल्का shape लौटाते हैं. कौन-सा headline metric भरा जाएगा यह task type पर निर्भर करता है - `mAP` detection-shaped tasks के लिए, `mIoU` semantic segmentation के लिए. ```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 } } ``` #### प्रतिक्रिया (pending, running, या failed) वही फ़ील्ड्स के बिना `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` गैर-detection मूल्यांकन कार्यों (उदा. classification, semantic segmentation) के लिए * `mIoU` foreground macro mean Intersection-over-Union है. यह केवल semantic segmentation evaluations के लिए भरा जाता है और `null` अन्यथा नहीं. * `precision` और `recall` test split के लिए F1-optimal confidence threshold पर रिपोर्ट किए जाते हैं. * `medianLatencyMs` Serverless Cloud API के server-side समय का मध्य मान है, मिलीसेकंड में, जिसे अधिकतम 500 test-split images पर मापा गया है. इसमें preprocessing और postprocessing समय शामिल है और network time शामिल नहीं है. यह `null` होता है जब मूल्यांकन ने इसे मापा नहीं. * `status` है `pending` जब evaluation मॉडल के inference के लिए compile होने की प्रतीक्षा कर रहा होता है. यह `running` हो जाता है जब evaluation job शुरू होता है. * `evalId` वही पहचानकर्ता है जो हर panel response में embedded होता है - `modelEvals.get` payload संरचनात्मक रूप से किसी भी panel payload का superset है, इसलिए एक `summary`-संवर्धित `modelEvals.get` और एक `getMapResults` response को उसी client code path से render किया जा सकता है. * `project` प्रोजेक्ट का URL slug है - वही पहचानकर्ता जिसे REST API URL paths में उपयोग करती है. मूल्यांकन UI से deep-link करने के लिए: `https://app.roboflow.com/{workspace}/{project}/evaluation/{versionId}`. `project` है `null` यदि प्रोजेक्ट हटा दिया गया है. * `modelId` मॉडल का URL slug ID है (`{workspace}/{model}`), या `{project}/{versionId}` एक evaluation के लिए जो single model के बजाय version पर चला था. यह `null` यदि मॉडल अब resolve नहीं किया जा सकता. ### Map Results मूल्यांकन के लिए primary metric विवरण लौटाता है. प्रतिक्रिया का shape task type पर निर्भर करता है: * **Object detection / instance segmentation** - IoU 0.5 / 0.5-0.95 / 0.75 पर mAP प्रति split, object size और per class के अनुसार विभाजित. * **Semantic segmentation** - mIoU, precision, recall, F1 (pixel-level) प्रति split, per-class IoU और optimal confidence thresholds के साथ. यह `taskType` response में field बताता है कि किस shape की अपेक्षा करनी है: `"object-detection-like"` या `"semantic-segmentation"`. यह वह डेटा है जिसे ऐप का **metrics per split** panel पढ़ता है. ```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 shape को अलग करता है. split contents पार्स करने से पहले हमेशा इसे जाँचें. * **Detection:** `map50_95` 0.5 से 0.95 तक 0.05 के चरणों में IoU thresholds पर औसत किया गया mAP है (COCO मानक). Object-size buckets हैं `null` जब split में उस size के कोई instances नहीं होते. Per-class entries `perClass`के अंतर्गत class name के आधार पर keyed होती हैं. * **Semantic segmentation:** सभी metrics foreground classes (background को छोड़कर) पर pixel-level macro means हैं. `miou` mean Intersection-over-Union है. `optimalThreshold` प्रति-class F1-optimal confidence threshold है. इसका मान `0.0` मान्य है और इसका अर्थ है कि model argmax पर peak करता है. ### Confidence Sweep प्रति-confidence-threshold metric curves और प्रत्येक split (और प्रति class) के लिए F1-optimal threshold लौटाता है. precision/recall trade-offs plot करने और deployment-time threshold चुनने के लिए उपयोगी. यह वह डेटा है जिसे ऐप का **production metrics explorer** panel पढ़ता है. ```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` keys confidence thresholds हैं decimal strings के रूप में, आमतौर पर हर `0.01` से `0.00` तक `0.99`. * `optimalThreshold` वह threshold है जो उस split के लिए F1 को अधिकतम करता है. * split के अंदर per-class entries में `perClass` नेस्टेड `perClass`. ### क्लास के अनुसार प्रदर्शन एक split के लिए प्रति-क्लास मुख्य मीट्रिक लौटाता है। प्रतिक्रिया का स्वरूप मूल्यांकन के कार्य-प्रकार पर निर्भर करता है: * **Object detection / instance segmentation** - प्रति-क्लास `map50`, `map50_95`, `map75`, precision, recall, F1, और इष्टतम threshold. * **Semantic segmentation** - प्रति-क्लास `iou`, precision, recall, F1, और इष्टतम threshold (पिक्सेल-स्तर). यह `taskType` प्रतिक्रिया में मौजूद field बताता है कि कौन-सा स्वरूप अपेक्षित है। यह वह डेटा है जिसे ऐप का **क्लास के अनुसार प्रदर्शन** panel पढ़ता है. ```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` | एनम | इनमें से एक `प्रशिक्षण`, `मान्यकरण`, `परीक्षण`. डिफ़ॉल्ट `परीक्षण`. `सभी` है **नहीं** यहाँ मान्य नहीं - प्रति-क्लास मीट्रिक को स्प्लिट्स के बीच एकत्रित नहीं किया जा सकता। | #### प्रतिक्रिया (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` प्रति-क्लास field set को अलग करता है। Detection classes में शामिल हैं `map50`/`map50_95`/`map75`; semantic segmentation classes में शामिल हैं `iou` और `classID` इसके बजाय. * `optimalThreshold` confidence sweep से प्राप्त प्रति-क्लास F1-उत्तम confidence threshold है। * `precision`, `recall`, और `f1` उस प्रति-क्लास इष्टतम threshold पर रिपोर्ट किए जाते हैं। * Detection के लिए, mAP fields हैं `null` जब उस class के instances split में नहीं होते। * Semantic segmentation के लिए, सभी metrics pixel-level हैं। एक `optimalThreshold` का `0.0` मान्य है। ### Confusion Matrix संयोजित confusion matrix लौटाता है, जो प्रति-छवि predictions से निकाली गई है। प्रत्येक cell `matrix[actual][predicted]` उन instances की संख्या है जिनमें ground-truth class `actual` था और model ने `predicted`भविष्यवाणी की। Semantic segmentation evaluations के लिए, मान instance counts के बजाय pixel counts का प्रतिनिधित्व करते हैं। यह वह डेटा है जिसे ऐप का **confusion matrix** panel पढ़ता है. ```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` | एनम | इनमें से एक `प्रशिक्षण`, `मान्यकरण`, `परीक्षण`, या `सभी`. डिफ़ॉल्ट `परीक्षण`. | | `confidence` | पूर्णांक | में confidence-threshold प्रतिशत `[0, 100]`. डिफ़ॉल्ट रूप से canonical file (आमतौर पर `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` instances #### नोट्स * `confidence` यह चुनता है कि report के अंतर्निहित per-confidence variant को किसे aggregate करना है। अलग-अलग thresholds अलग-अलग matrices देते हैं। * `split=all` train, valid, और test के raw counts को aggregate करता है। ### वेक्टर विश्लेषण मूल्यांकन के लिए image-embedding clustering output लौटाता है - HDBSCAN द्वारा clustered UMAP-projected embeddings, प्रति-cluster aggregate metrics के साथ। उन image समूहों को पहचानने में उपयोगी जहाँ model व्यवस्थित रूप से बेहतर या खराब प्रदर्शन करता है। यह वह डेटा है जिसे ऐप का **वेक्टर विश्लेषण** panel पढ़ता है. ```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` | पूर्णांक | में 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"] } ] } ``` #### नोट्स * Cluster id `-1` noise/unclustered bucket (HDBSCAN convention) है - images जो किसी भी dense region में फिट नहीं होतीं। * `precisionMean` और `recallMean` को cluster की सभी images पर औसत किया जाता है। * प्रति-छवि embeddings और cluster assignments यहाँ उपलब्ध कराए जाते हैं [प्रति-छवि भविष्यवाणियाँ](#per-image-predictions). ### प्रति-छवि भविष्यवाणियाँ प्रति-छवि prediction records लौटाता है - TP/FP/FN counts, प्रति-छवि precision/recall/F1, image का cluster id और 2D embedding, और raw confusion entries। Paginated. यह वह डेटा है जिसे ऐप का **प्रति-छवि भविष्यवाणियाँ** panel पढ़ता है. ```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` | एनम | इनमें से एक `प्रशिक्षण`, `मान्यकरण`, `परीक्षण`, या `सभी`. डिफ़ॉल्ट `सभी`. | | `confidence` | पूर्णांक | में confidence-threshold प्रतिशत `[0, 100]` (यह चुनता है कि किस per-confidence report variant को पढ़ना है). | | `limit` | पूर्णांक | पृष्ठ आकार; डिफ़ॉल्ट `200`, अधिकतम `1000`. | | `offset` | पूर्णांक | वापस करने से पहले इतने 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]` triples; 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`. * **Pagination cost**: प्रत्येक page पूरे `model_eval_results.json` file को storage से फिर पढ़ता है और server-side उसे slice करता है। बहुत बड़े `image_results` arrays वाले evals के लिए, प्रति-page fixed cost को कम करने हेतु कई छोटे pages की बजाय बड़े `limit` मानों (तक `1000`) को प्राथमिकता दें। ### सिफारिशें पूर्ण किए गए evaluation से उत्पन्न model improvement recommendations लौटाता है - class-imbalance warnings, missed-detection patterns, और यह कि अपने dataset में क्या जोड़ना है या retrain कैसे करना है, इस बारे में अन्य actionable सुझाव। यह वह डेटा है जिसे ऐप का **मॉडल सुधार सिफारिशें** panel पढ़ता है. यह endpoint है **केवल-पठन**. Recommendations training completion के side effect के रूप में (या legacy in-app "Refresh Recommendations" action के माध्यम से) उत्पन्न होती हैं। यदि वे अभी तक उत्पन्न नहीं हुई हैं, तो response है `200 {"generated": false}` - ध्यान दें कि यह है **नहीं** एक `409 EVAL_NOT_DONE`. evaluation *है* पूरा हो गया है; बस इसमें optional recommendations side-output नहीं है। Other panel endpoints (`map-results`, `confidence-sweep`, आदि.) लौटाते हैं `409 EVAL_NOT_DONE` जब उनका backing data अनुपलब्ध हो, क्योंकि वह data evaluation का अभिन्न हिस्सा है; 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" ``` #### प्रतिक्रिया (recommendations उपलब्ध हैं) ```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) से जोड़ें और यह इन उपकरणों के साथ मॉडल के प्रदर्शन की समीक्षा कर सकता है:
उपकरणविवरण
model_evals_listवर्कस्पेस में model evaluations की सूची बनाएं।
model_evals_getएक evaluation के लिए शीर्ष-स्तरीय summary प्राप्त करें।
model_evals_get_map_resultsप्रति-split mAP परिणाम प्राप्त करें।
model_evals_get_confusion_matrixconfusion matrix प्राप्त करें।
model_evals_get_performance_by_classएक split के लिए प्रति-क्लास प्रदर्शन मीट्रिक प्राप्त करें।
model_evals_get_recommendationsयदि उपलब्ध हो, तो evaluation के लिए उत्पन्न सिफारिशें प्राप्त करें।