> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ovalbee.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ovalbee.com/_mcp/server.

# Train a detector

Once you have labeled images, fine-tuning a detector takes three nodes. The **Train EdgeCrafter Detector on Images** template is the starting point, and the same shape works with YOLO and DEIM.

```mermaid
flowchart LR
  dataset["Dataset"] --> split["Train/val split"] --> train["Train EdgeCrafter"]
```

**Nodes:** [Dataset](/node-library/nodes/dataset-ops-dataset), [Train/validation split](/node-library/nodes/sample-train-validation-split), and a training node — [Train EdgeCrafter](/node-library/nodes/models-edgecrafter-train-edgecrafter), [Train YOLO](/node-library/nodes/models-yolo-train-yolo) or [Train DEIM](/node-library/nodes/models-deim-train-deim).

#### Point the flow at labeled data

Set the Dataset node to a dataset with box annotations — for example the *Accepted* dataset of a [labeling flow](/use-cases/organize-labeling). Choose its *@latest* version if later retraining should pick up newly accepted images.

#### Split it

The split node writes a training and a validation dataset. If your images already carry split tags — Dataset Ninja imports do — you can keep the original split instead of drawing a new one.

#### Choose where training starts

The training node's **Model** is a model in your registry. To start from pretrained weights, first copy one from **Models** → **Catalog** with **Add to registry**. To continue from an earlier run, pick the model it produced. The classes come from your datasets, and **Hyperparameters** holds the number of epochs, the batch size and the image size, with defaults that work for a first run.

#### Run and watch the report

Run the training node. It needs a GPU worker. Open its report while it runs: it's live, and shows validation metrics epoch by epoch and predictions on example images.

## What you get

* **A model version** in the [registry](/concepts/models): the best checkpoint, its class list, metrics, training parameters, the datasets it was trained and validated on, and the training report. Run the node again and the same model gets a new version.
* **A training report** that answers the question the headline number doesn't: did the run converge, and where did it stop improving? The best checkpoint is often not the last one, and the curves show why.

**See it running:** [live example](https://app.ovalbee.com/public/flows/train-edgecrafter-detector-on-images) · [case study](https://ovalbee.com/case-studies/detector-training-pcb)

## Make it yours

* **Evaluate it properly.** Validation metrics come from the split used during training. For a verdict you can defend, score the model on a held-out set with [Evaluate object detection](/use-cases/evaluate-and-compare).
* **Train two and pick one.** Add a second training branch with another architecture and compare them on the same data — see [Evaluate and compare models](/use-cases/evaluate-and-compare).
* **Retrain on a schedule.** Give the training node a schedule and point it at the latest version of your accepted dataset. Each run adds a model version, and prediction nodes that use the model's *@latest* pick it up.
* **Export it.** [Export YOLO](/node-library/nodes/models-yolo-export-yolo) and [Export DEIM](/node-library/nodes/models-deim-export-deim) convert trained models for deployment outside OvalBee.