Getitune Preparing Datasets
Developmentgetitune-preparing-datasetsGetitune Preparing Datasets 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.
Prepare and point datasets at the getitune library (the Geti training library) for training, testing, and prediction. Use when a user asks which dataset formats are supported, how the `data=` argument of `create_engine(...)` / `--data_root` works, why format auto-detection fails, how to lay out COCO/YOLO/Pascal VOC/Datumaro-native data, how to use a zip archive, or how to pass an Ultralytics YOLO `data.yaml`. Covers Datumaro-based auto-detection and per-task data expectations.
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-preparing-datasets/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/getitune-preparing-datasets, 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.
Preparing datasets for getitune
When you pass a filesystem path to data= (Python API) or --data_root (CLI),
getitune uses Datumaro to
auto-detect the dataset format — you point at the dataset root and the same
call works regardless of the underlying format.
Run everything from library/.
Supported formats and how they are detected
| Format | Detected by |
|---|---|
| COCO | an annotations/ directory with COCO JSON files |
| YOLO | a data.yaml file (Ultralytics layout) |
| Pascal VOC | JPEGImages/, Annotations/, ImageSets/ directories |
| Datumaro (native) | metadata.json + data.parquet at the root |
- Zip archives are accepted too; Datumaro extracts them on import.
- Point
data=at the dataset root — the directory that directly contains the marker files/folders above, not a parent of it.
Workflow
from getitune.engine import create_engine
# Same call for any supported format — just point at the root
engine = create_engine(
model="src/getitune/recipe/detection/yolox_s.yaml",
data="/path/to/dataset_root",
)
engine.train()
- Lay the dataset out as one supported format and confirm the marker
files/folders sit at the root you will pass.
- Done when: the root matches exactly one row in the table above.
- Match the dataset to the task. A detection dataset needs bounding-box
annotations; segmentation needs masks; classification needs per-image labels.
Task and labels must agree with the model you choose in the
getitune-training-a-modelskill.- Done when:
create_engine(...)builds a datamodule without a feature/label mismatch error.
- Done when:
- Smoke-test loading with a tiny run (
engine.train(max_epochs=1)) before a full run.- Done when: one train + one validation batch load without shape errors.
Ultralytics YOLO datasets
If you train an Ultralytics YOLO model, pass the Ultralytics
data.yaml file directly as data=
(or --data_root). Ultralytics support requires an install from source with the
ultralytics extra (it is not in the PyPI package).
Debugging auto-detection
- Wrong/failed format detection: the root probably has extra nesting or a
missing marker. Verify the exact marker files (
annotations/for COCO,data.yamlfor YOLO, the three VOC dirs,metadata.json+data.parquetfor native) are directly under the path you pass. - Feature/label mismatch during training: the dataset's annotation type does
not match the task — cross-check with
getitune-training-a-modeland pass an explicittask=. - Backend dataset conversion: the Geti application converts Geti-internal
datasets to/from COCO/VOC via
application/backend/app/datumaro_converter/; that is a separate, app-side path from librarydata=usage.
Related skills
getitune-training-a-model— consumes the prepared dataset viadata=.getitune-discovering-models— pick a model that matches the dataset's task.