Getitune Training A Model
Developmentgetitune-training-a-modelGetitune Training A Model is an Agent Skill for development published in the open-edge-platform/geti repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.
Train a computer-vision model with the getitune library (the Geti training library) using its Python API or CLI. Use when a user wants to train, fine-tune, or evaluate a model with `create_engine(...)` and `engine.train()/engine.test()`, run `getitune train`/`getitune test`, pick or override a recipe under `getitune.recipe.<task>`, choose a device (cpu/gpu/xpu/cuda), warm-start from a checkpoint, or debug a training run. Covers classification, detection, instance/semantic segmentation, and keypoint detection.
How to use this skill
Bring this guide into your coding agent with a prompt tailored to the tool you use.
- Open your project in Codex.
- Copy and paste the prompt below.
- Review files and risks before approving any action.
Inspect the Agent Skill at https://github.com/open-edge-platform/geti/blob/HEAD/skills/library/getitune-training-a-model/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/getitune-training-a-model, but wait for my approval before writing files or running scripts.
Copying this prompt does not install or run the skill. Review third-party files before use.
Training a model with getitune
getitune is a low-code transfer-learning library. Training is driven by an
Engine created with create_engine(...), which pairs a model/recipe with a
dataset and returns a runnable engine. Recipes (YAML under
library/src/getitune/recipe/<task>/) bundle model + data pipeline + training
config, so a model name alone gives a strong baseline.
There are two equal entry points that share the same objects and recipes:
- Python API —
from getitune.engine import create_engine, thenengine.train()/engine.test(). Preferred for notebooks, scripts, tests, and library integration. Seelibrary/README.md("Quick Start") andlibrary/docs/source/guide/get_started/api_tutorial.rst. - CLI —
getitune train --data_root <path> --model <name|recipe.yaml>. Preferred for reproducible experiments and shell workflows. Seelibrary/docs/source/guide/get_started/cli_commands.rst.
Run everything from library/. Install with the extra that matches your
hardware: uv sync (cpu), uv sync --extra xpu, or uv sync --extra cuda.
Python API workflow
from getitune.engine import create_engine
engine = create_engine(
model="efficientnet_b0", # model name, recipe .yaml path, or model class
data="/path/to/dataset_root", # dataset root (COCO/YOLO/VOC/native), auto-detected
work_dir="./my_workspace", # checkpoints + logs; defaults to ./getitune-workspace
device="auto", # "auto", "cpu", "gpu", "xpu", "cuda", "0", ...
)
engine.train(max_epochs=50)
engine.test()
- Pick the model/recipe. Pass a model name (
"efficientnet_b0"), a recipe path ("src/getitune/recipe/detection/yolox_s.yaml"), or a model class. If a name matches recipes under several tasks, passtask=(e.g.task="DETECTION") to disambiguate. Use thegetitune-discovering-modelsskill to list options.- Done when:
create_engine(...)returns without aValueError/FileNotFoundError.
- Done when:
- Point
data=at the dataset root. Format is auto-detected by Datumaro; see thegetitune-preparing-datasetsskill.- Done when: the engine builds a datamodule without a format/feature error.
- Smoke-test the wiring first with a tiny run (
engine.train(max_epochs=1)or a small subset) before a long run.- Done when: one train + one validation pass complete without shape errors.
- Train, overriding hyperparameters as needed
(
engine.train(max_epochs=50)).- Done when: checkpoints appear under
work_dir.
- Done when: checkpoints appear under
- Evaluate with
engine.test()and confirm the task metric moves, not just loss. Record the model +work_dirthat produced it.
Warm-start from existing weights with
create_engine(..., checkpoint="/path/to/weights.pt").
CLI workflow
# from library/
# 1. Simplest: data only — getitune picks a default model for the task
getitune train --data_root /path/to/dataset
# 2. Choose a model or recipe
getitune train --data_root /path/to/dataset --model yolox_s
# 3. Override hyperparameters
getitune train --data_root /path/to/dataset --model yolox_s \
--max_epochs 200 --checkpoint /path/to/weights.pt
# 4. Run a full, resolved config file
getitune train --data_root /path/to/dataset --config src/getitune/recipe/detection/yolox_s.yaml
getitune test and getitune predict share the same --model / --data_root
shape. Use getitune <cmd> --help -v (and -vv) for the full overridable
argument list.
Choosing a device
device="auto"selects an available accelerator; force with"cpu","gpu","xpu","cuda", or an index like"0".- The device must match the installed extra —
--extra xpufor Intel GPUs,--extra cudafor NVIDIA. Guard nothing yourself; the library handles capability checks.
Debugging a run
- Run one epoch on a small dataset first to isolate construction vs. dataloading vs. training failures.
- Shape/feature mismatches usually mean the dataset's labels or task disagree
with the model — recheck
task=and the dataset format (getitune-preparing-datasets). - Dataset auto-detection failures: confirm the folder matches one supported layout (COCO/YOLO/VOC/native).
Verify
# from library/
just lint
just test-unit -- -k engine # when you changed engine/training code
For API-facing work, add or run a short Python smoke test that calls
create_engine(...) + engine.train(max_epochs=1) on a tiny fixture rather than
a long real run.
Related skills
getitune-discovering-models— list models/recipes and disambiguate by task.getitune-preparing-datasets— thedata=half of the engine.getitune-exporting-a-model— export a trained checkpoint to OpenVINO/ONNX.getitune-running-inference— run predictions with a trained or exported model.geti-library-dev— when the library/model code itself needs changes.