> 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

## के बारे में

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

{% hint style="info" %}
सक्रिय शिक्षण के लिए क्लाउड डिप्लॉयमेंट आवश्यक है। यह Annotation Review सुविधा वाले प्लानों पर उपलब्ध है।
{% endhint %}

## वेब ऐप

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

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

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

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

सक्रिय शिक्षण में कॉन्फ़िगरेशन की दो श्रेणियाँ हैं: संग्रह सीमाएँ और शर्तें।

#### संग्रह सीमाएँ

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

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

इन सेटिंग्स को संपादित करने के लिए, "संग्रह सीमाएँ" अनुभाग में "संपादित करें" पर क्लिक करें और कॉन्फ़िगरेशन मोडल में मान अपडेट करें।

#### शर्तें

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

* विश्वास-सीमाएँ (उदा.: ऐसी छवियाँ एकत्र करें जहाँ विश्वास 60% से नीचे गिरता है)
* रुचि के विशिष्ट वर्ग
* डिटेक्शन गणना आवश्यकताएँ

शर्तें सेट करने के लिए, "शर्तें" अनुभाग में "संपादित करें" पर क्लिक करें।

### एजेंट से सक्रिय शिक्षण प्रबंधित करें

आप भी सक्रिय शिक्षण प्रबंधित कर सकते हैं [Roboflow Agent](https://docs.roboflow.com/agents/agents/roboflow-agent). एक प्रोजेक्ट टैब खोलें, "सेटिंग्स" चुनें, और इस पृष्ठ की तरह ही वही टॉगल, संग्रह सीमाएँ, और शर्तें उपयोग करें। इसके लिए Manage Workflows, Publish Workflows, और Dataset Active Learning अनुमतियाँ चाहिए।

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

जैसे-जैसे सक्रिय शिक्षण छवियाँ एकत्र करता है, वे सक्रिय शिक्षण पृष्ठ के छवियाँ अनुभाग में दिखाई देती हैं। पृष्ठ समीक्षा के लिए तैयार छवियों और वर्तमान में समीक्षा की जा रही छवियों की गिनती दिखाता है।

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

1. "छवियों की समीक्षा करें" पर क्लिक करके समीक्षा कतार खोलें।
2. स्थिति (प्रारंभ नहीं हुआ, प्रगति में) के अनुसार बैच ब्राउज़ करें और निर्माण तिथि, छवि संख्या, या प्रगति के आधार पर क्रमित करें।
3. समीक्षा शुरू करने के लिए एक बैच चुनें।

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

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

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

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

### सक्रिय शिक्षण आपके प्रशिक्षण लूप में कैसे फिट होता है

सामान्य वर्कफ़्लो:

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

यह एक फीडबैक लूप बनाता है जहाँ आपका मॉडल उन मामलों में बेहतर होता है जहाँ उसे सबसे अधिक कठिनाई होती है।

## HTTP API

सक्रिय शिक्षण को सक्षम या अक्षम करने, संग्रह नियम अपडेट करने, और समीक्षा कतार में छवियाँ सूचीबद्ध करने के लिए HTTP API का उपयोग करें। एंडपॉइंट्स उपयोग करते हैं `https://api.roboflow.com` और `api_key` क्वेरी पैरामीटर, अनुरोध बॉडी, या बेयरर प्राधिकरण हेडर में API कुंजी की आवश्यकता होती है।

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

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

प्रतिक्रिया में प्रोजेक्ट, डिप्लॉयमेंट वर्कफ़्लो, चुना गया मॉडल, डिप्लॉय करने की योग्यता, और सक्रिय शिक्षण कॉन्फ़िगरेशन शामिल होते हैं:

```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": "दैनिक",
      "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` प्रतिक्रिया का मतलब है कि वर्कफ़्लो डिप्लॉय करने योग्य नहीं है। प्रतिक्रिया का आकार वही है जो [सक्रिय शिक्षण कॉन्फ़िगरेशन प्राप्त करें](#get-active-learning-configuration), साथ `activeLearning.enabled` को सेट किया गया हो `सत्य`.

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

<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` को सेट किया गया हो `असत्य`.

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

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

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

नए प्रोजेक्ट पर इसे कॉन्फ़िगर करने से पहले सक्रिय शिक्षण सक्षम करें। अनुरोध में शामिल होना चाहिए `collectionLimits`. `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": "दैनिक",
      "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
      }
    ]
  }'
```

आवश्यक संग्रह सीमा फ़ील्ड हैं:

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

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

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

* `classConfidence`: किसी विश्वास सीमा के भीतर चुने गए वर्गों के लिए भविष्यवाणियाँ एकत्र करें। `classFilterMode` हो सकता है `"any"`, `"in"`या `"out"`.
* `detectionSize`: बीच वाले बाउंडिंग बॉक्स के साथ भविष्यवाणियाँ एकत्र करें `sizeLowerPercentage` और `sizeUpperPercentage` छवि आकार का। यह फ़िल्टर केवल ऑब्जेक्ट डिटेक्शन और इंस्टेंस सेगमेंटेशन प्रोजेक्ट्स का समर्थन करता है। अन्य प्रोजेक्ट प्रकार `400`.

प्रतिक्रिया का आकार वही है जो [सक्रिय शिक्षण कॉन्फ़िगरेशन प्राप्त करें](#get-active-learning-configuration). एक `400` प्रतिक्रिया में अमान्य संग्रह सीमाओं या फ़िल्टरों के लिए वैधता विवरण शामिल होते हैं।

### सक्रिय शिक्षण छवियों की सूची बनाएं

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

एंडपॉइंट इन वैकल्पिक क्वेरी पैरामीटरों को स्वीकार करता है:

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

प्रतिक्रिया में समीक्षा कतार की गिनतियाँ, पृष्ठांकित कतार आइटम, बैच, एनोटेशन जॉब, और छवि कुल शामिल होते हैं:

```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()` एक डायरेक्टरी की हर छवि पर इन्फरेंस चलाता है और शर्तों के आधार पर छवि (और उसकी भविष्यवाणी) को गंतव्य प्रोजेक्ट पर अपलोड करता है। यह SDK का अंतर्निहित सक्रिय-शिक्षण लूप है: अपने मौजूदा मॉडल को यह तय करने देकर कि क्या लेबल किया जाना चाहिए, कच्चे फुटेज से एक लेबलिंग कतार तैयार करें।

वही पैटर्न सबसे अच्छा एक [वर्कफ़्लो](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk) के रूप में बनाया जाता है, उत्पादन उपयोग के लिए, लेकिन `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],   # [प्रोजेक्ट, संस्करण]
    upload_destination="my-detector",         # गंतव्य प्रोजेक्ट
    conditionals={
        "required_class_variance_count": 1,           # कम से कम 1 अलग वर्ग
        "minimum_size_requirement": 100,              # प्रति डिटेक्शन न्यूनतम पिक्सेल
        "maximum_size_requirement": 4000000,
        "confidence_interval": [0, 60],               # केवल कम-विश्वास वाली भविष्यवाणियाँ
    },
)
```

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

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

### इसे क्यों उपयोग करें

सामान्य लूप:

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

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

### बड़े पाइपलाइन

यदि आपका इनपुट एक वीडियो स्ट्रीम है, आपका मॉडल किसी Workflow के पीछे रहता है, या आप batching और retries चाहते हैं, तो समकक्ष को एक [वर्कफ़्लो](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk). `active_learning()` के रूप में बनाना एक static फ़ोल्डर से one-off bootstrapping passes के लिए सबसे अच्छा है।