> 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/deployment/hi/monitoring-and-analytics/active-learning.md).

# Active Learning

## के बारे में

सक्रिय शिक्षण आपके तैनात मॉडल्स से production डेटा एकत्र करता है और उसे समीक्षा तथा पुनः-प्रशिक्षण के लिए प्रस्तुत करता है. जब आपका मॉडल production में inference चलाता है, तो सक्रिय शिक्षण आपके द्वारा कॉन्फ़िगर किए गए नियमों के आधार पर स्वचालित रूप से छवियों का सैंपल लेता है (जैसे कम-confidence भविष्यवाणियाँ या विशिष्ट वर्ग) और उन्हें मानवीय समीक्षा के लिए कतार में डाल देता है.

{% hint style="info" %}
सक्रिय शिक्षण के लिए cloud deployment आवश्यक है. यह Annotation Review फीचर वाले plans पर उपलब्ध है.
{% endhint %}

## वेब ऐप

### सक्रिय शिक्षण सक्षम करें

1. अपना Project खोलें और बाएँ साइडबार में "Active Learning" चुनें.
2. सक्रिय शिक्षण को चालू करें.

सक्रिय शिक्षण द्वारा डेटा एकत्र करने के लिए आपके Project में एक प्रशिक्षित मॉडल और एक सक्रिय cloud deployment होना चाहिए.

### संग्रह नियम कॉन्फ़िगर करें

सक्रिय शिक्षण में कॉन्फ़िगरेशन की दो श्रेणियाँ हैं: collection limits और conditions.

#### Collection Limits

नियंत्रित करें कि सक्रिय शिक्षण कितना डेटा एकत्र करता है:

* सैंपलिंग दर: सैंपल किए जाने वाले inference का प्रतिशत (उदा.: 0.5%)
* प्रति-मिनट, प्रति-घंटा, और प्रति-दिन छवि सीमाएँ
* संपीड़न स्तर और अधिकतम छवि आयाम
* बैच पुनर्निर्माण आवृत्ति (दैनिक, साप्ताहिक, मासिक, या कभी नहीं)
* क्या एकत्र की गई छवियों के साथ मॉडल भविष्यवाणियों को बनाए रखना है

इन सेटिंग्स को संपादित करने के लिए, Collection Limits अनुभाग में "Edit" क्लिक करें और configuration modal में मान अपडेट करें.

#### Conditions

Conditions यह फ़िल्टर करते हैं कि कौन-सी छवियाँ एकत्र की जाएँ. आप अपने मॉडल प्रकार के आधार पर नियम परिभाषित कर सकते हैं:

* Confidence thresholds (उदा.: ऐसी छवियाँ एकत्र करें जहाँ confidence 60% से नीचे हो)
* रुचि के विशिष्ट वर्ग
* Detection count आवश्यकताएँ

Conditions सेट करने के लिए, Conditions अनुभाग में "Edit" क्लिक करें.

### Agent से Active Learning प्रबंधित करें

आप Active Learning को भी प्रबंधित कर सकते हैं [Roboflow Agent](https://docs.roboflow.com/agents/roboflow-agent). एक project tab खोलें, "Settings" चुनें, और इस पेज की तरह ही वही toggle, Collection Limits, और Conditions उपयोग करें. इसके लिए Manage Workflows, Publish Workflows, और Dataset Active Learning अनुमतियाँ चाहिए.

### एकत्रित छवियों की समीक्षा करें

जैसे-जैसे Active Learning छवियाँ एकत्र करता है, वे Active Learning पेज के Images अनुभाग में दिखाई देती हैं. पेज समीक्षा के लिए तैयार छवियों और वर्तमान में समीक्षा की जा रही छवियों की संख्या दिखाता है.

समीक्षा शुरू करने के लिए:

1. समीक्षा कतार खोलने के लिए "Review Images" क्लिक करें.
2. स्थिति (Not Started, In Progress) के आधार पर batches ब्राउज़ करें और creation date, image count, या progress के अनुसार sort करें.
3. समीक्षा शुरू करने के लिए एक batch चुनें.

### समीक्षकों को असाइन करें

आप समीक्षा कार्य को अपनी टीम में वितरित कर सकते हैं:

1. समीक्षा कतार खोलें और एक batch चुनें.
2. समीक्षकों को असाइन करने के लिए क्लिक करें.
3. टीम सदस्यों को चुनें, असाइन की जाने वाली छवियों की संख्या सेट करें, और वैकल्पिक रूप से समीक्षा निर्देश जोड़ें.
4. "Shuffle Images" को चालू करें ताकि यह यादृच्छिक हो जाए कि प्रत्येक समीक्षक को कौन-सी छवियाँ मिलती हैं.

जब छवियाँ उन्हें असाइन की जाती हैं, तो समीक्षकों को सूचना दी जाती है. आप किसी भी समय छवियों को किसी अन्य समीक्षक को पुनः असाइन कर सकते हैं.

### सक्रिय शिक्षण आपके प्रशिक्षण चक्र में कैसे फिट बैठता है

सामान्य कार्यप्रवाह:

1. एक मॉडल को प्रशिक्षित और तैनात करें.
2. अपने उपयोग मामले के अनुसार ट्यून की गई conditions के साथ सक्रिय शिक्षण सक्षम करें.
3. आपकी conditions से मेल खाने वाला production डेटा एकत्र होकर कतार में डाल दिया जाता है.
4. समीक्षक एकत्रित छवियों को लेबल करते हैं.
5. समीक्षित छवियों को अपने dataset में जोड़ें और अपने मॉडल को बेहतर बनाने के लिए पुनः-प्रशिक्षित करें.

इससे एक feedback loop बनता है, जहाँ आपका मॉडल उन मामलों में बेहतर होता जाता है जहाँ उसे सबसे अधिक कठिनाई होती है.

## HTTP API

सक्रिय शिक्षण को सक्षम या अक्षम करने, संग्रह नियम अपडेट करने, और समीक्षा कतार में छवियों को सूचीबद्ध करने के लिए HTTP API का उपयोग करें. endpoints `https://api.roboflow.com` का उपयोग करते हैं और `api_key` query parameter, request body, या bearer authorization header में API key की आवश्यकता होती है.

### सक्रिय शिक्षण कॉन्फ़िगरेशन प्राप्त करें

<mark style="color:हरा;">`GET`</mark> `/:workspace/:project/deploy/active-learning`

आवश्यक स्कोप: `project:read`

```bash
curl "https://api.roboflow.com/my-workspace/my-project/deploy/active-learning?api_key=$ROBOFLOW_API_KEY"
```

प्रतिक्रिया में Project, deployment Workflow, चुना गया मॉडल, deployability, और Active Learning configuration शामिल है:

```json
{
  "project": { "url": "my-project", "name": "मेरा प्रोजेक्ट" },
  "workflow": { "url": "my-project-base-workflow" },
  "model": {
    "id": "rfdetr-medium",
    "kind": "पूर्व-प्रशिक्षित",
    "displayName": "RF-DETR Medium",
    "modelId": "rfdetr-medium"
  },
  "deployability": {
    "status": "तैनात करने योग्य",
    "modelWasConfigured": false,
    "selectedModelId": null,
    "selectionReason": null
  },
  "activeLearning": {
    "enabled": false,
    "collectionLimits": {
      "dataPercentage": 100,
      "minutelyUsageLimit": 10,
      "hourlyUsageLimit": 100,
      "dailyUsageLimit": 1000,
      "labelingBatchesRecreationFrequency": "daily",
      "usageQuotaName": "upload_quota_active_learning",
      "imageCompressionLevel": 95,
      "maxImageHeight": 1080,
      "maxImageWidth": 1920,
      "persistPredictions": true
    },
    "filters": []
  }
}
```

### सक्रिय शिक्षण सक्षम करें

<mark style="color:हरा;">`POST`</mark> `/:workspace/:project/deploy/active-learning/enable`

आवश्यक स्कोप: `project:update`

```bash
curl -X POST "https://api.roboflow.com/my-workspace/my-project/deploy/active-learning/enable" \
  -H "Content-Type: application/json" \
  -d '{ "api_key": "'$ROBOFLOW_API_KEY'" }'
```

यदि कोई मॉडल कॉन्फ़िगर नहीं है, तो सेवा एक चुनने का प्रयास करती है. एक `400` प्रतिक्रिया का मतलब है कि Workflow तैनात करने योग्य नहीं है. प्रतिक्रिया की संरचना भी उसी जैसी है [सक्रिय शिक्षण कॉन्फ़िगरेशन प्राप्त करें](#get-active-learning-configuration), जिसमें `activeLearning.enabled` को सेट किया गया है `true`.

### सक्रिय शिक्षण अक्षम करें

<mark style="color:हरा;">`POST`</mark> `/:workspace/:project/deploy/active-learning/disable`

आवश्यक स्कोप: `project:update`

```bash
curl -X POST "https://api.roboflow.com/my-workspace/my-project/deploy/active-learning/disable" \
  -H "Content-Type: application/json" \
  -d '{ "api_key": "'$ROBOFLOW_API_KEY'" }'
```

प्रतिक्रिया की संरचना भी [सक्रिय शिक्षण कॉन्फ़िगरेशन प्राप्त करें](#get-active-learning-configuration), जिसमें `activeLearning.enabled` को सेट किया गया है `false`.

### सक्रिय शिक्षण कॉन्फ़िगरेशन अपडेट करें

<mark style="color:हरा;">`POST`</mark> `/:workspace/:project/deploy/active-learning/configuration`

आवश्यक स्कोप: `project:update`

नए Project पर इसे कॉन्फ़िगर करने से पहले सक्रिय शिक्षण सक्षम करें. अनुरोध में `collectionLimits`शामिल होना चाहिए.  `filters` array वैकल्पिक है. यदि आप इसे छोड़ देते हैं, तो मौजूदा filters नहीं बदलते.

```bash
curl -X POST "https://api.roboflow.com/my-workspace/my-project/deploy/active-learning/configuration" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "'$ROBOFLOW_API_KEY'",
    "collectionLimits": {
      "dataPercentage": 50,
      "minutelyUsageLimit": 10,
      "hourlyUsageLimit": 100,
      "dailyUsageLimit": 1000,
      "labelingBatchesRecreationFrequency": "daily",
      "usageQuotaName": "default",
      "imageCompressionLevel": 85,
      "imageName": "camera-1",
      "maxImageHeight": 1080,
      "maxImageWidth": 1920,
      "registrationTags": ["production"],
      "persistPredictions": true
    },
    "filters": [
      {
        "type": "classConfidence",
        "classFilterMode": "any",
        "classes": ["cat"],
        "confidenceLowerBound": 0.2,
        "confidenceUpperBound": 0.8
      }
    ]
  }'
```

आवश्यक collection limit फ़ील्ड हैं:

* `dataPercentage`: एकत्र किए जाने वाले inference का प्रतिशत, से `0` तक `100`
* `minutelyUsageLimit`: प्रति मिनट एकत्र की जाने वाली अधिकतम छवियाँ, या `0` असीमित के लिए
* `hourlyUsageLimit`: प्रति घंटे एकत्र की जाने वाली अधिकतम छवियाँ
* `dailyUsageLimit`: प्रति दिन एकत्र की जाने वाली अधिकतम छवियाँ
* `labelingBatchesRecreationFrequency`: `"never"`, `"daily"`, `"weekly"`, या `"monthly"`
* `usageQuotaName`: एक गैर-रिक्त quota पहचानकर्ता

वैकल्पिक फ़ील्ड हैं `imageCompressionLevel`, `imageName`, `registrationTags`, और `persistPredictions`. छवियों का आकार बदलने के लिए, दोनों प्रदान करें `maxImageHeight` और `maxImageWidth`. केवल एक प्रदान करने पर मौजूदा छवि आकार सीमा हट जाती है.

सक्रिय शिक्षण दो filter प्रकारों का समर्थन करता है:

* `classConfidence`: confidence सीमा के भीतर चुने गए वर्गों के लिए predictions एकत्र करें. `classFilterMode` हो सकता है `"any"`, `"in"`, या `"out"`.
* `detectionSize`: image size के `sizeLowerPercentage` और `sizeUpperPercentage` के बीच bounding boxes वाली predictions एकत्र करें. यह filter केवल object detection और instance segmentation Projects का समर्थन करता है. अन्य Project प्रकार `400`.

प्रतिक्रिया की संरचना भी [सक्रिय शिक्षण कॉन्फ़िगरेशन प्राप्त करें](#get-active-learning-configuration). एक `400` प्रतिक्रिया में अमान्य collection limits या filters के लिए validation विवरण शामिल होते हैं.

### Active Learning छवियों की सूची

<mark style="color:हरा;">`GET`</mark> `/:workspace/:project/deploy/active-learning/images`

आवश्यक स्कोप: `project:read`

```bash
curl "https://api.roboflow.com/my-workspace/my-project/deploy/active-learning/images?api_key=$ROBOFLOW_API_KEY&page=1&pageSize=20"
```

यह endpoint इन वैकल्पिक query parameters को स्वीकार करता है:

* `page`: पृष्ठ संख्या, शुरू होती है `1`
* `pageSize`: प्रति पृष्ठ आइटम, अधिकतम `50`
* `search`: पाठ को queue नामों, प्रकारों, IDs, समीक्षकों और लेबलर्स से मिलाया जाता है
* `reviewer`: समीक्षक का ईमेल या `"unassigned"`
* `status`: `"all"`, `"not_started"`, या `"in_progress"`
* `sortBy`: `"created"`, `"images"`, या `"progress"`
* `sortDirection`: `"asc"` या `"desc"`

प्रतिक्रिया में review queue counts, paginated queue items, batches, annotation jobs, और image totals शामिल हैं:

```json
{
  "activeLearningImages": {
    "totalImagesReadyForReview": 0,
    "totalImagesBeingReviewed": 0,
    "batches": [],
    "annotationJobs": [],
    "latestBatch": null,
    "latestAnnotationJob": null,
    "sampleImages": [],
    "reviewQueueCounts": {
      "all": 0,
      "notStarted": 0,
      "inProgress": 0
    },
    "reviewQueuePage": {
      "page": 1,
      "pageSize": 20,
      "totalItems": 0,
      "totalPages": 1,
      "items": [],
      "search": "",
      "status": "all",
      "sortBy": "created",
      "sortDirection": "desc",
      "reviewer": ""
    }
  }
}
```

## Python SDK

`Workspace.active_learning()` यह किसी directory की हर छवि पर inference चलाता है और शर्तों के आधार पर छवि (और उसकी prediction) को destination project में अपलोड करता है. यह SDK का built-in active-learning loop है: अपने मौजूदा मॉडल को यह तय करने देकर कि क्या लेबल करना उचित है, raw footage से एक labeling queue तैयार करें.

उसी पैटर्न को एक [Workflow](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk) के रूप में production use के लिए बनाना सबसे अच्छा है, लेकिन `active_learning()` "मेरे पास फ़्रेम्स का एक फ़ोल्डर है" से "प्रोजेक्ट में जाने वाला लेबल किया गया डेटा" तक पहुँचने का सबसे तेज़ रास्ता है.

### बुनियादी उपयोग

```python
import roboflow

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

ws.active_learning(
    raw_data_location="./frames",
    raw_data_extension=".jpg",
    inference_endpoint=["my-detector", 3],   # [project, version]
    upload_destination="my-detector",         # गंतव्य प्रोजेक्ट
    conditionals={
        "required_class_variance_count": 1,           # कम से कम 1 अलग वर्ग
        "minimum_size_requirement": 100,              # प्रति detection न्यूनतम पिक्सेल
        "maximum_size_requirement": 4000000,
        "confidence_interval": [0, 60],               # केवल कम-confidence भविष्यवाणियाँ
    },
)
```

#### पैरामीटर

* `raw_data_location` (str) - input छवियों की directory.
* `raw_data_extension` (str) - मिलान करने के लिए image extension (उदा. `.jpg`, `.png`).
* `inference_endpoint` (list, `[project, version]`) - triage चरण के रूप में चलाने वाला मॉडल.
* `upload_destination` (str) - जिस project id में योग्य छवियाँ और predictions अपलोड करनी हैं. अक्सर वही प्रोजेक्ट जो मॉडल के लिए है.
* `conditionals` (dict) - ऐसे नियम जो तय करते हैं कि कोई छवि अपलोड होगी या नहीं. सामान्य keys:
  * `confidence_interval` - `[min, max]`; केवल वे छवियाँ जिनकी detections इस सीमा में आती हैं, आगे भेजी जाती हैं.
  * `required_class_variance_count` - आवश्यक न्यूनतम अलग-अलग वर्गों की संख्या.
  * `minimum_size_requirement` / `maximum_size_requirement` - detection क्षेत्र के आधार पर फ़िल्टर करें.
  * `required_class_count` - कुल detections.
* `use_localhost` (bool, default `False`) - जब `True`, तो hosted inference के बजाय एक self-hosted [Roboflow Inference](/deployment/hi/self-hosted/self-hosted.md) server को हिट करें.
* `local_server` (str) - local inference server के लिए base URL. डिफ़ॉल्ट है `http://localhost:9001/`.

### इसे क्यों इस्तेमाल करें

सामान्य चक्र:

1. छोटे labeled set पर v1 model को प्रशिक्षित करें.
2. निर्देशित करें `active_learning()` एक unlabeled production data फ़ोल्डर की ओर.
3. केवल वही छवियाँ आगे भेजें जहाँ मॉडल अनिश्चित है (low confidence) या दुर्लभ वर्ग देखता है.
4. उन्हें Roboflow web app में लेबल करें.
5. नई उदाहरणों के साथ v2 बनाएँ और पुनः-प्रशिक्षित करें.

ट्यूनिंग `conditionals` इसी चीज़ से यह "सब कुछ अपलोड करें" से एक वास्तविक triage policy बनता है.

### बड़े pipelines

यदि आपका input एक video stream है, आपका model एक Workflow के पीछे रहता है, या आप batching और retries चाहते हैं, तो समकक्ष को एक [Workflow](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk). `active_learning()` एक static folder से one-off bootstrapping passes के लिए सबसे अच्छा है.

## MCP Server

अपने AI agent को से कनेक्ट करें [MCP Server](https://docs.roboflow.com/agents/mcp-server) और यह इन tools के साथ Active Learning सेट कर सकता है:

<table data-search="false"><thead><tr><th width="290">Tool</th><th>विवरण</th></tr></thead><tbody><tr><td><code>project_deployment_enable_active_learning</code></td><td>एक Project Deployment के लिए Active Learning सक्षम करें.</td></tr><tr><td><code>project_deployment_configure_active_learning</code></td><td>कॉन्फ़िगर करें कि एक deployment Active Learning डेटा कैसे एकत्र करता है.</td></tr><tr><td><code>project_deployment_disable_active_learning</code></td><td>Active Learning संग्रह रोकें.</td></tr><tr><td><code>project_deployment_list_review_queues</code></td><td>production inference द्वारा फ़ीड की गई review queues की सूची बनाएं.</td></tr></tbody></table>