Getitune Running Inference
Testing & Qualitygetitune-running-inferenceGetitune Running Inference is an Agent Skill for testing & quality published in the open-edge-platform/geti repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.
Run inference and evaluation with a getitune model (the Geti training library). Use when a user wants to call `engine.predict()` / `engine.test()` or `getitune predict` / `getitune test`, run inference with a PyTorch checkpoint versus an exported OpenVINO IR (`.xml`) or ONNX (`.onnx`) model, or understand how `OVEngine` loads deployed models via ModelAPI. Covers PyTorch, OpenVINO, and ONNX inference backends.
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-running-inference/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/getitune-running-inference, 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.
Running inference with getitune
getitune runs inference through engine.predict() (per-item predictions) and
engine.test() (metrics on the test subset). The same calls work whether the
engine holds a PyTorch model or an exported OpenVINO/ONNX model — the
backend is selected from what you pass to model=.
Run everything from library/.
PyTorch inference (trained model)
from getitune.engine import create_engine
engine = create_engine(
model="efficientnet_b0",
data="/path/to/dataset",
)
test_metrics = engine.test() # metrics on the test subset
predictions = engine.predict() # predictions on the test subset
OpenVINO / ONNX inference (exported model)
from getitune.engine import create_engine
# OpenVINO IR — pass the .xml
ov_engine = create_engine(model="/path/to/exported_model.xml", data="/path/to/dataset")
ov_engine.test()
ov_engine.predict()
# ONNX — pass the .onnx
onnx_engine = create_engine(model="/path/to/exported_model.onnx", data="/path/to/dataset")
onnx_engine.test()
onnx_engine.predict()
Passing an .xml or .onnx path builds an OVEngine, which loads the model via
ModelAPI.
Workflow
- Pick the model surface. Use a model name/checkpoint for PyTorch inference,
or an exported
.xml/.onnxfor deployed inference.- Done when:
create_engine(...)returns the expected engine type.
- Done when:
- Point
data=at a dataset with a test subset (seegetitune-preparing-datasets).- Done when:
engine.test()runs without a data/format error.
- Done when:
- Run
test()for metrics orpredict()for per-item outputs.- Done when: metrics are produced, or predictions are returned for each item.
- Compare backends when validating an export. PyTorch vs OpenVINO/ONNX
metrics should closely match (small numeric drift is expected).
- Done when: exported-model metrics are within tolerance of the PyTorch model.
CLI
# from library/
getitune predict --data_root /path/to/dataset --model efficientnet_b0
getitune test --data_root /path/to/dataset --model /path/to/exported_model.xml
Related skills
getitune-exporting-a-model— produce the.xml/.onnxused here.getitune-optimizing-a-model— run inference with an INT8 quantized model.getitune-preparing-datasets— thedata=half of inference.