डेटासेट संस्करण

प्रशिक्षण से पहले preprocessing और augmentation के साथ point-in-time snapshots के रूप में डेटासेट संस्करण बनाएं।

परिचय

संस्करण आपके डेटासेट में छवियों और लेबलों के समय-बिंदु स्नैपशॉट होते हैं। जब आप एक संस्करण बनाते हैं, तो आप अपने डेटासेट पर पूर्व-प्रसंस्करण चरण और ऑगमेंटेशन लागू कर सकते हैं।

Roboflow में एक मॉडल को प्रशिक्षित करने के लिए, आपको एक Dataset Version बनाना होगा।

हमारे दस्तावेज़ीकरण का यह भाग बताता है कि मॉडल को प्रशिक्षित करने की तैयारी कैसे करें। आपको यह करना होगा:

1

Versions पेज खोलें और एक नया संस्करण बनाएं

हमारे मार्गदर्शक का पालन करें ताकि आप पहुँच सकें उस पेज पर जो आपको डेटासेट संस्करण बनाने देता है.

2

पूर्व-प्रसंस्करण चरण चुनें

चुनें पूर्व-प्रसंस्करण चरण जिनकी आपको अपना मॉडल प्रशिक्षित करने के लिए आवश्यकता है।

3

ऑगमेंटेशन लागू करें

अपने डेटासेट पर कोई भी ऑगमेंटेशन लागू करें. हमारे पास एक मार्गदर्शिका है जो बताती है कि अलग-अलग उपयोग मामलों के लिए कौन-से ऑगमेंटेशन उपयुक्त हैं।

4

अपने संस्करण की पुष्टि करें

आपका संस्करण बनाया जाएगा और अब मॉडल प्रशिक्षण में उपयोग के लिए उपलब्ध होगा।

5

मॉडल प्रशिक्षित करें

हमारे मॉडल प्रशिक्षण दस्तावेज़ीकरण का उपयोग अपने प्रशिक्षण जॉब को कॉन्फ़िगर करने के लिए करें।

आप यह भी डेटासेट संस्करण निर्यात कर सकते हैं.

HTTP API

एक संस्करण देखें

आप Python SDK, REST API, और CLI का उपयोग करके Roboflow संस्करण के बारे में जानकारी प्राप्त कर सकते हैं।

संस्करण ID

Roboflow में जनरेट किए गए प्रत्येक संस्करण के साथ एक क्रमिक, संख्यात्मक ID जुड़ी होती है। आप इसे अपने versions पेज पर ऐप के माध्यम से देख सकते हैं या API में अपने प्रोजेक्ट संस्करणों की सूची बनाकर देख सकते हैं।

यदि आपको पहले से पता है कि किस प्रोजेक्ट और संस्करण के बारे में जानकारी प्राप्त करनी है, तो आप इसका उपयोग कर सकते हैं /:workspace/:project/:version एंडपॉइंट। यह प्रोजेक्ट एंडपॉइंट जैसी ही जानकारी लौटाता है, लेकिन प्रोजेक्ट के अन्य सभी संस्करणों की सूची नहीं देता।

किसी प्रोजेक्ट के बारे में जानकारी प्राप्त करने के लिए, निम्नलिखित एंडपॉइंट पर एक GET अनुरोध करें:

https://api.roboflow.com/roboflow/chess-sample-4ckfl/1?api_key=$ROBOFLOW_API_KEY

यह एंडपॉइंट निम्नलिखित प्रतिक्रिया लौटाता है:

{
    "workspace": {
        "name": "Roboflow",
        "url": "roboflow",
        "members": 7
    },
    "project": {
        "id": "roboflow/chess-sample-4ckfl",
        "type": "object-detection",
        "name": "Chess Sample",
        "created": 1630335544.592,
        "updated": 1630335741.988,
        "images": 12,
        "unannotated": 3,
        "annotation": "pieces",
        "public": false,
        "splits": {
            "test": 1,
            "valid": 2,
            "train": 9
        },
        "classes": {
            "black-knight": 11,
            "black-queen": 4,
            "black-king": 8,
            "white-king": 8,
            "white-pawn": 34,
            "black-bishop": 8,
            "white-rook": 10,
            "black-pawn": 37,
            "white-knight": 10,
            "white-bishop": 11,
            "black-rook": 10,
            "white-queen": 7
        }
    },
    "version": {
        "id": "roboflow/chess-sample-4ckfl/1",
        "name": "augmented",
        "created": 1630335698.746,
        "images": 30,
        "splits": {
            "valid": 2,
            "test": 1,
            "train": 27
        },
        "model": {
            "id": "chess-sample-4ckfl/1",
            "endpoint": "https://serverless.roboflow.com/infer/chess-sample-4ckfl/1",
            "start": 1630335799.682,
            "end": 1630337523.889,
            "fromScratch": false,
            "tfjs": true,
            "oak": true,
            "map": "62.87",
            "recall": "85.29",
            "precision": "23.44"
        },
        "preprocessing": {
            "resize": {
                "height": 416,
                "width": 416,
                "format": "Stretch to",
                "enabled": true
            },
            "auto-orient": {
                "enabled": true
            },
            "grayscale": {
                "enabled": true
            }
        },
        "augmentation": {
            "rotate": {
                "degrees": "5",
                "enabled": true
            },
            "brightness": {
                "darken": true,
                "enabled": true,
                "brighten": true,
                "percent": "25"
            },
            "noise": {
                "percent": "2",
                "enabled": true
            },
            "crop": {
                "enabled": true,
                "min": 0,
                "percent": 30
            },
            "flip": {
                "horizontal": true,
                "vertical": false,
                "enabled": true
            },
            "image": {
                "versions": "3",
                "enabled": true
            },
            "exposure": {
                "enabled": true,
                "percent": "25"
            }
        },
        "exports": [
            "yolov5pytorch"
        ],
        "train": {
            "status": "finished",
            "results": {
                "class_map": {
                    "valid": [
                        {
                            "images": "20",
                            "map95": "0.29",
                            "precision": "0.795",
                            "recall": "0.48",
                            "map50": "0.547",
                            "class": "all",
                            "targets": "82"
                        },
                        ...
                    ],
                    "test": [
                        {
                            "images": "10",
                            "map95": "0.478",
                            "precision": "0.846",
                            "recall": "0.759",
                            "map50": "0.844",
                            "class": "all",
                            "targets": "29"
                        },
                        ...
                    ]
                }
            }
        },
        "models": {
            "roboflow-train": {
                "epochs": [
                    {
                        "mAP": "0.5624740875589795",
                        "epoch": "0",
                        "precision": "0.848007354583702",
                        "recall": "0.4796292117720689",
                        "box_loss": "0.04430354",
                        "obj_loss": "0.023823218",
                        "class_loss": "0.012277425",
                        "mAP_50_95": "0.3004394102727502"
                    },
                    {
                        "mAP": "0.5576528999996365",
                        "epoch": "1",
                        "precision": "0.8477760345230224",
                        "recall": "0.47967238365789094",
                        "box_loss": "0.041422606",
                        "obj_loss": "0.020020777",
                        "class_loss": "0.010422977",
                        "mAP_50_95": "0.2943194093111112"
                    },
                    ...
                ]
            }
        },
        "classes": [
            "black-knight",
            "black-queen",
            "black-king",
            "white-king",
            "white-pawn",
            "black-bishop",
            "white-rook",
            "black-pawn",
            "white-knight",
            "white-bishop",
            "black-rook",
            "white-queen"
        ]
    }
}

कीपॉइंट डिटेक्शन स्केलेटन

कीपॉइंट डिटेक्शन प्रोजेक्ट संस्करणों में एक स्केलेटन फ़ील्ड होगा, जिसमें प्रत्येक class के लिए आपके संस्करण के स्केलेटन होते हैं। उदाहरण के लिए, जिस प्रोजेक्ट में class person होगी, उसमें निम्नलिखित स्केलेटन हो सकता है:

{
...
"skeletons": {
    "person": {
        "vertices": [
            {
                "color": "#FF8000",
                "id": 0,
                "name": "nose",
                "x": 0.4546,
                "y": 0.18859999999999996
            },
            {
                "color": "#FF00FF",
                "id": 1,
                "name": "left_eye"
                "x": 0.478,
                "y": 0.1606
            },
            ...
        ],
        "edges": [
            {
                "color": "#00FFCE",
                "from": 13,
                "to": 15
            },
            ...
        ],
        "symmetries": [
            {
                "direction": "horizontal",
                "points": [1, 2]
            },
            ...
        ]
    }
}

ध्यान दें, inference predictions के साथ vertices को इंडेक्स के आधार पर एक्सेस किया जाना चाहिए class_id. फिर, vertex id का उपयोग edge (from/to) और symmetries (points) को संदर्भित करने के लिए किया जा सकता है।

Python SDK

एक संस्करण देखें

किसी संस्करण के बारे में जानकारी प्राप्त करने के लिए, प्रोजेक्ट लें और जिस संस्करण की आपको आवश्यकता है उसका अनुरोध करें:

import roboflow

rf = roboflow.Roboflow(api_key="YOUR_API_KEY")

# एक प्रोजेक्ट प्राप्त करें
project = rf.workspace().project("PROJECT_ID")

model = project.version("1").model

यह मॉडल वेरिएबल में निम्नलिखित JSON मान होते हैं:

{
  "id": "mug-detector-eocwp/12",
  "name": "Mug Detector",
  "version": "12",
  "classes": null,
  "overlap": 30,
  "confidence": 40,
  "stroke": 1,
  "labels": false,
  "format": "json",
  "base_url": "https://serverless.roboflow.com/infer/"
}

सूचीबद्ध करने और संस्करणों पर iterating के लिए, देखें वर्कस्पेस और प्रोजेक्ट सूचीबद्ध करें. किसी संस्करण को निर्यात करने के लिए, देखें डेटासेट संस्करण निर्यात करें.

CLI

आप कमांड लाइन से डेटासेट संस्करणों की सूची बना सकते हैं, उनका निरीक्षण कर सकते हैं, और उन्हें निर्यात कर सकते हैं।

संस्करण सूचीबद्ध करें

roboflow version list -p <project>

उदाहरण:

roboflow version list -p my-detector

ID                              NAME              IMAGES  CREATED
my-workspace/my-detector/1      raw               100     2024-01-15
my-workspace/my-detector/2      augmented-640     300     2024-01-20
my-workspace/my-detector/3      augmented-416     250     2024-02-01

संस्करण विवरण प्राप्त करें

roboflow version get -p <project> <version-number>

या संसाधन शॉर्टहैंड का उपयोग करें:

roboflow version get my-detector/3
roboflow version get my-workspace/my-detector/3

एक संस्करण निर्यात करें

किसी विशिष्ट प्रारूप में किसी संस्करण का async निर्यात ट्रिगर करें:

roboflow version export -p <project> <version-number> -f <format>

उदाहरण:

roboflow version export -p my-detector 3 -f yolov8

JSON आउटपुट

सभी version कमांड समर्थन करते हैं --json:

roboflow version list -p my-detector --json

[
  {
    "id": "my-workspace/my-detector/1",
    "name": "raw",
    "images": 100,
    "created": "2024-01-15T00:00:00"
  }
]

MCP सर्वर

अपने AI एजेंट को जोड़ें MCP सर्वर और यह इन टूल्स से डेटासेट संस्करणों का प्रबंधन कर सकता है:

टूल	विवरण
versions_generate	वैकल्पिक पूर्व-प्रसंस्करण और ऑगमेंटेशन के साथ एक संस्करण बनाएं।
versions_get	splits और इसकी trainings सहित संस्करण जानकारी प्राप्त करें।
versions_export	किसी संस्करण के लिए डेटासेट निर्यात की जाँच करें या उसे ट्रिगर करें।
versions_delete	किसी संस्करण को हटाएँ, जिससे वह workspace Trash में चला जाएगा।

अगले चरण

• अपने संस्करण का उपयोग करके एक मॉडल प्रशिक्षित करें। देखें मॉडल प्रशिक्षित करें.

• अपने संस्करण को प्रशिक्षण-तैयार प्रारूप में निर्यात करें। देखें डेटासेट संस्करण निर्यात करें.