> 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/datasets/hi/versions/dataset-versions.md).

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

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

## परिचय

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

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

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

{% stepper %}
{% step %}
**Versions पेज खोलें और एक नया संस्करण बनाएं**

हमारे मार्गदर्शक का पालन करें ताकि आप पहुँच सकें [उस पेज पर जो आपको डेटासेट संस्करण बनाने देता है](/datasets/hi/versions/dataset-versions/create-a-dataset-version.md).
{% endstep %}

{% step %}
**पूर्व-प्रसंस्करण चरण चुनें**

चुनें [पूर्व-प्रसंस्करण चरण](/datasets/hi/versions/dataset-versions/image-preprocessing.md) जिनकी आपको अपना मॉडल प्रशिक्षित करने के लिए आवश्यकता है।
{% endstep %}

{% step %}
**ऑगमेंटेशन लागू करें**

[अपने डेटासेट पर कोई भी ऑगमेंटेशन लागू करें](/datasets/hi/versions/dataset-versions/image-augmentation.md). हमारे पास एक मार्गदर्शिका है जो बताती है कि अलग-अलग उपयोग मामलों के लिए कौन-से ऑगमेंटेशन उपयुक्त हैं।
{% endstep %}

{% step %}
**अपने संस्करण की पुष्टि करें**

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

{% step %}
**मॉडल प्रशिक्षित करें**

हमारे [मॉडल प्रशिक्षण दस्तावेज़ीकरण](https://docs.roboflow.com/models) का उपयोग अपने प्रशिक्षण जॉब को कॉन्फ़िगर करने के लिए करें।

आप यह भी [डेटासेट संस्करण निर्यात कर सकते हैं](/datasets/hi/versions/dataset-versions/exporting-data.md).
{% endstep %}
{% endstepper %}

## HTTP API

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

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

#### संस्करण ID

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

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

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

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

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

```bash
{
    "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` होगी, उसमें निम्नलिखित स्केलेटन हो सकता है:

```json
{
...
"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

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

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

```python
import roboflow

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

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

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

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

```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 के लिए, देखें [वर्कस्पेस और प्रोजेक्ट सूचीबद्ध करें](https://docs.roboflow.com/platform/workspaces/list-workspaces-and-projects#list-projects-and-versions). किसी संस्करण को निर्यात करने के लिए, देखें [डेटासेट संस्करण निर्यात करें](/datasets/hi/versions/dataset-versions/exporting-data.md#python-sdk).

## CLI

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

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

```bash
roboflow version list -p <project>
```

उदाहरण:

```bash
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
```

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

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

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

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

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

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

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

उदाहरण:

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

### JSON आउटपुट

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

```bash
roboflow version list -p my-detector --json
```

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

## MCP सर्वर

अपने AI एजेंट को जोड़ें [MCP सर्वर](https://docs.roboflow.com/agents/mcp-server) और यह इन टूल्स से डेटासेट संस्करणों का प्रबंधन कर सकता है:

<table data-search="false"><thead><tr><th width="290">टूल</th><th>विवरण</th></tr></thead><tbody><tr><td><code>versions_generate</code></td><td>वैकल्पिक पूर्व-प्रसंस्करण और ऑगमेंटेशन के साथ एक संस्करण बनाएं।</td></tr><tr><td><code>versions_get</code></td><td>splits और इसकी trainings सहित संस्करण जानकारी प्राप्त करें।</td></tr><tr><td><code>versions_export</code></td><td>किसी संस्करण के लिए डेटासेट निर्यात की जाँच करें या उसे ट्रिगर करें।</td></tr><tr><td><code>versions_delete</code></td><td>किसी संस्करण को हटाएँ, जिससे वह workspace Trash में चला जाएगा।</td></tr></tbody></table>

## अगले चरण

* अपने संस्करण का उपयोग करके एक मॉडल प्रशिक्षित करें। देखें [मॉडल प्रशिक्षित करें](https://docs.roboflow.com/models).
* अपने संस्करण को प्रशिक्षण-तैयार प्रारूप में निर्यात करें। देखें [डेटासेट संस्करण निर्यात करें](/datasets/hi/versions/dataset-versions/exporting-data.md).
