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

# Active Learning

## About

Active Learning collects production data from your deployed models and surfaces it for review and retraining. When your model runs inference in production, Active Learning automatically samples images based on rules you configure (such as low-confidence predictions or specific classes) and queues them for human review.

{% hint style="info" %}
Active Learning requires a cloud deployment. It is available on plans with the Annotation Review feature.
{% endhint %}

## Web App

### Enable Active Learning

1. Open your Project and select "Active Learning" in the left sidebar.
2. Toggle Active Learning on.

Your Project must have a trained model and an active cloud deployment for Active Learning to collect data.

### Configure Collection Rules

Active Learning has two categories of configuration: collection limits and conditions.

#### Collection Limits

Control how much data Active Learning collects:

* Sampling rate: the percentage of inferences to sample (ex: 0.5%)
* Per-minute, hourly, and daily image caps
* Compression level and maximum image dimensions
* Batch recreation frequency (daily, weekly, monthly, or never)
* Whether to persist model predictions with collected images

To edit these settings, click "Edit" in the Collection Limits section and update the values in the configuration modal.

#### Conditions

Conditions filter which images get collected. You can define rules based on your model type:

* Confidence thresholds (ex: collect images where confidence falls below 60%)
* Specific classes of interest
* Detection count requirements

To set up conditions, click "Edit" in the Conditions section.

### Review Collected Images

As Active Learning collects images, they appear in the Images section of the Active Learning page. The page shows counts of images ready for review and images currently being reviewed.

To start reviewing:

1. Click "Review Images" to open the review queue.
2. Browse batches by status (Not Started, In Progress) and sort by creation date, image count, or progress.
3. Select a batch to begin reviewing.

### Assign Reviewers

You can distribute review work across your team:

1. Open the review queue and select a batch.
2. Click to assign reviewers.
3. Choose team members, set the number of images to assign, and optionally add review instructions.
4. Toggle "Shuffle Images" to randomize which images each reviewer receives.

Reviewers are notified when images are assigned to them. You can reassign images to a different reviewer at any time.

### How Active Learning Fits Your Training Loop

The typical workflow:

1. Train and deploy a model.
2. Enable Active Learning with conditions tuned to your use case.
3. Production data that matches your conditions is collected and queued.
4. Reviewers label the collected images.
5. Add the reviewed images to your dataset and retrain to improve your model.

This creates a feedback loop where your model improves on the cases where it struggles most.

## HTTP API

You can manage Active Learning programmatically through the [Project Deploy API](https://docs.roboflow.com/deployment#project-deploy-api). The API lets you enable/disable Active Learning, update collection limits and filters, and list collected images.

## Python SDK

`Workspace.active_learning()` runs inference on every image in a directory and conditionally uploads the image (and its prediction) to a destination project. It's the SDK's built-in active-learning loop: bootstrap a labeling queue from raw footage by letting your existing model triage what's worth labeling.

The same pattern is best built as a [Workflow](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk) for production use, but `active_learning()` is the fastest path from "I have a folder of frames" to "labelled data going into a project".

### Basic usage

```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",         # destination project
    conditionals={
        "required_class_variance_count": 1,           # at least 1 different class
        "minimum_size_requirement": 100,              # min pixels per detection
        "maximum_size_requirement": 4000000,
        "confidence_interval": [0, 60],               # only low-confidence predictions
    },
)
```

#### Parameters

* `raw_data_location` (str) - directory of input images.
* `raw_data_extension` (str) - image extension to match (e.g. `.jpg`, `.png`).
* `inference_endpoint` (list, `[project, version]`) - the model to run as the triage step.
* `upload_destination` (str) - project id to upload qualifying images and predictions into. Often the same project as the model.
* `conditionals` (dict) - rules that determine whether an image gets uploaded. Common keys:
  * `confidence_interval` - `[min, max]`; only images whose detections fall in this range are forwarded.
  * `required_class_variance_count` - minimum distinct classes required.
  * `minimum_size_requirement` / `maximum_size_requirement` - filter by detection area in pixels.
  * `required_class_count` - total detections.
* `use_localhost` (bool, default `False`) - when `True`, hit a self-hosted [Roboflow Inference](https://inference.roboflow.com) server instead of hosted inference.
* `local_server` (str) - base URL for the local inference server. Defaults to `http://localhost:9001/`.

### Why use it

The typical loop:

1. Train a v1 model on a small labeled set.
2. Point `active_learning()` at a folder of unlabeled production data.
3. Forward only the images where the model is uncertain (low confidence) or sees rare classes.
4. Label those in the Roboflow web app.
5. Generate v2 with the new examples and retrain.

Tuning `conditionals` is what turns this from "upload everything" into a real triage policy.

### Bigger pipelines

If your input is a video stream, your model lives behind a Workflow, or you want batching and retries, build the equivalent as a [Workflow](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk). `active_learning()` is best for one-off bootstrapping passes from a static folder.