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

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

के बारे में

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

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

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

1

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

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

2

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

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

3

संवर्धन लागू करें

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

4

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

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

5

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

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

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

HTTP API

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

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

संस्करण ID

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

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

किसी प्रोजेक्ट के बारे में जानकारी प्राप्त करने के लिए, निम्नलिखित एंडपॉइंट पर एक 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": "संवर्धित",
        "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"
        ]
    }
}

कीपॉइंट पहचान कंकाल

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

{
...
"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 को index द्वारा एक्सेस किया जाना चाहिए 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

यह model चर में निम्नलिखित JSON मान होते हैं:

{
  "id": "mug-detector-eocwp/12",
  "name": "मग डिटेक्टर",
  "version": "12",
  "classes": null,
  "overlap": 30,
  "confidence": 40,
  "stroke": 1,
  "labels": false,
  "format": "json",
  "base_url": "https://serverless.roboflow.com/infer/"
}

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

CLI

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

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

roboflow version list -p <project>

उदाहरण:

roboflow version list -p my-detector

ID                              NAME              IMAGES  CREATED
my-workspace/my-detector/1      कच्चा               100     2024-01-15
my-workspace/my-detector/2      संवर्धित-640     300     2024-01-20
my-workspace/my-detector/3      संवर्धित-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": "कच्चा",
    "images": 100,
    "created": "2024-01-15T00:00:00"
  }
]

अगले चरण

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

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