Label a small first batch by hand, then let the detector grow its own training set. Each round trains on everything labeled so far, finds where the model fails on the validation set, picks the most similar unlabeled images, has a live training session pre-label them, and adds the ones it is sure about to the training set - for as many rounds as you set.
Overview
- Task: Object detection, labeling only the images the model most needs
- Input: A dataset of unlabeled images, with the classes you want to detect in its ontology
- Models: a YOLO detector retrained every round, and a Grounding DINO live training session that pre-labels the images
- Pipeline: split and index the images → label a random first batch, the validation set and the test set → train → evaluate on validation → pick unlabeled images similar to the failures → pre-label them and accept the confident ones → train again, for 10 rounds → evaluate on the test set
- Output: a learning curve of validation mAP against the number of labeled images, a model version per round, a labeled dataset and a final test evaluation
When you need it
You have far more images than you can afford to label, and every label should move the model as much as possible. A random sample spends most of the budget on easy images the model already handles. This template has people label only the first batch and the images the model is scored on, and lets the model find and label the rest of what it needs.
What you need
- A dataset of images to label, with the classes you want to detect in its ontology. Setup asks for it.
- A Grounding DINO model for the live training session. Setup asks for it and starts the session.
- A YOLO model to train, chosen on Train YOLO. Copy one from the model zoo. Every round trains from the version you pick and saves the result as a new version.
- Labelers and classes, chosen on Label train, validation and test.
- A GPU for training.
The template creates every other dataset it needs.
How it works
The flow is drawn in four groups, with the live training session beside them.
| Step | What happens |
|---|---|
| Dataset setup | Run Images to label. The images are split 70/10/20 into a pool to label from, a validation set and a test set, and indexed for image similarity |
| Bootstrap | A random batch of pool images, 30 by default, goes to labeling together with the validation and test sets. Label train, validation and test hands them out from one queue per labeler, in that order, and keeps each set's labeled images in a dataset of its own. Label the first images of the batch by hand, with Live Training switched on in the labeling tool so every submit trains the session. Once it predicts well, run Prelabeling with live training: in one run, every image of the batch, the validation set and the test set not labeled yet gets the session's boxes, and those where every box scores 0.8 or more count as labeled, each in its own set's labeled dataset. The rest wait in the labeling tool with boxes drawn |
| Train | Once the first batch and the validation set are labeled, run Train YOLO. From here on the loop runs by itself |
| Evaluate | The model predicts on the validation set and is scored there. The score is added to the learning curve |
| Stop or go on | The loop stops after 10 rounds, counted on the learning curve. Change the number on Stop after 10 rounds |
| Pick the next batch | The validation images with the lowest scores become seeds. The pool images most similar to them, minus those already labeled, are picked, 30 per round by default |
| Pre-label and accept | The live training session pre-labels the picked images. Those where every box scores 0.8 or more join the training set, and the next round's training starts |
| Final evaluation | When the loop stops, run Predict on test. The last model is scored on the test set |
Nobody checks the images the loop accepts, so the confidence you accept at decides how many mistakes reach the training set. Images the session is less sure about are left out rather than labeled; a later round can pick them again. The live training session learns only from what people submit, so in the loop it stays as good as it was when the bootstrap ended, and only the detector keeps improving.
The loop only ever looks at the validation set, and nothing but the final evaluation reads the test set. Validation and test images accepted without review score the model against the live training session's guesses, which makes both scores optimistic. For honest numbers, turn off Also the other sets of its labeling step and label those two sets by hand. The next batch is chosen from the validation failures, so the learning curve on validation runs somewhat optimistic. The final test evaluation gives the honest number.
What a run gives you
- A learning curve report that grows by one point per round: validation mAP 50-95 and mAP 50 against the number of labeled images, and the model version behind each point.
- A model version per round, each with its training report.
- An evaluation report per round on the validation set, and a final one on the test set.
- A labeled dataset holding every image labeled or accepted so far, ready to use outside the loop, and labeled validation and test sets beside it.
Related templates
- Labeling with auto quality check - add a rule-based check and a review step when labels need a second pair of eyes
- Detector evaluation - score the final model on another held-out set once the loop is done