Skip to content

Geti v3.0.0

Choose a tag to compare

View all tags
@yvolokitin yvolokitin released this 18 Jun 13:01
· 325 commits to develop since this release
app/v3.0.0
d3633a2
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.
image

🚀 Geti™ v3.0.0 — AI development moves to the edge

Geti 3.0 marks a fundamental achievement in the evolution of vision AI development. Geti is now a lightweight application that runs directly on edge devices and AI PC hardware, while still remaining compatible with traditional cloud and cluster‑based infrastructure.
With Geti v3 you can fine‑tune models and run inference directly on edge and client hardware — including Intel® Panther Lake and Arc™ Battlemage (B‑series) GPUs — keeping your data, training, and deployment on the same machine.

The result is a faster, simpler, and edge-native way to go from data to a deployed model: on a laptop, a workstation, or an edge device.

🔷 Major features and improvements

A whole new installation experience:

  • Native Windows app — run Geti directly on Windows via a simple MSIX installer.

  • Single Docker image — run Geti from one container on Linux or Windows, while maintaining compatibility with Kubernetes deployments.

State‑of‑the‑art model architectures

  • RF‑DETR S / M / L (Roboflow) — a real‑time DETR transformer on a DINOv2 backbone, SOTA accuracy/latency on COCO, for detection and instance segmentation.

  • DINOv3 DETR S / M / L — Meta's DINOv3 self‑supervised backbone combined with DEIMv2 + DETR for high‑quality detection with less labeled data.

A new Ultralytics integration introduces YOLO26 — the latest NMS‑free, edge‑optimized models (Nano / Small / Medium) for object detection and instance segmentation. The integration covers the full model lifecycle: training, inference, quantization, and OpenVINO™ model export.

Dramatically lower hardware requirements: Geti v3 no longer depends on Kubernetes as the default architecture, the overall footprint is significantly reduced requiring fewer CPU resources and less memory (the minimum recommended configuration is 8 CPU threads, 16 GB RAM, and 40 GB of free disk space)[VJ1.1][YV1.2]. Smaller models can be trained on CPU with modest memory usage, while a GPU is recommended for larger models.

Apache 2.0 license: Geti 3.0 code is now under the permissive Apache 2.0 license, simplifying adoption, integration, and redistribution.

More features:

  • Dataset versioning - track how datasets evolve as images and annotations are added, with the ability to explore revisions, link models to a specific dataset state, and train on any prior revision.

  • Model versioning / lineage - track model lineage with links to parent revisions and weights, view exact training hyperparameters, and fine-tune from any previous model version.

  • Configurable training devices - select from available hardware (CPU, GPU), including specific GPUs in multi-device setups.

  • 16‑bit media support - train and infer on 16-bit single-channel images and video with configurable intensity range preprocessing (not supported for YOLOX‑S/M/L).

  • Decoupled edge-ready pipelines - build flexible inference pipelines where data sources (e.g. cameras, files, streams) and output targets can be swapped or reconfigured without retraining models, enabling easier integration and faster iteration across different deployment scenarios.

  • Pipeline export for edge deployment - package complete pipelines, including model, preprocessing, and configuration, into OpenVINO™‑optimized bundles ready for deployment on edge and Intel®‑based hardware.

  • Integrated deployment & inference — a new Inference page builds custom pipelines (source → model → sink) to deploy models inside Geti and monitor predictions in real time. Sources include USB/IP cameras and video files; optional sinks include MQTT, webhook, and folder.

  • Improved evaluation metrics - expanded training-time and evaluation metrics, including mAP at multiple thresholds for detection and segmentation tasks, providing deeper insight into model performance.

  • Label filtering for dataset import/export - selectively include or exclude labels during dataset export and import, automatically filtering out associated annotations.

  • Native dataset format (Geti) - export and import datasets in a Geti‑optimized format, designed for improved performance on large datasets while preserving full metadata.

  • Manual subset assignment - explicitly assign images and video frames to training, validation, or test subsets in the annotator, with safeguards to prevent data leakage and automatic assignment for unassigned media.

  • Real‑time training logs - monitor training logs live during job execution and access them later via the UI for improved observability and troubleshooting.

  • Demo scripts for inference - exported ONNX and OpenVINO™ model packages include example scripts to run inference on sample images, simplifying validation and onboarding.

  • Bulk annotation for classification - assign one or more labels to multiple images or video frames at once, significantly speeding up annotation workflows.

  • Accuracy‑aware quantization - define acceptable accuracy drop during INT8 model optimization, enabling better trade‑offs between inference performance and accuracy.

Some features from earlier versions are no longer included in v3 or have been reworked:

If you rely on any of the capabilities below or are exploring alternatives, we encourage you to join the conversation in our GitHub Discussions. Your feedback helps shape the roadmap, and the community may also share practical workarounds or migration strategies.

Documentation:

  • The REST API has been redesigned — see the updated specification; model export and deployment have been simplified and streamlined, with improved performance achieved by using the Model API instead of the SDK

  • Migration notes: models trained in 2.x must be retrained in Geti v3. This can be achieved by exporting the dataset from Geti 2.x and importing it to Geti v3. Projects with multiple datasets require each dataset to be exported and imported separately — please follow the migration guidance.

Download this release

Windows Installer (run Geti as a native Windows application, with prebuilt images for Intel® XPU, NVIDIA® CUDA, and CPU-only environments):
Download CPU-only version installer.
Download Intel® XPU version installer.
Download Nvidia® CUDA version installer

Docker Images
ghcr.io/open-edge-platform/geti-cpu:3.0.0
ghcr.io/open-edge-platform/geti-xpu:3.0.0
ghcr.io/open-edge-platform/geti-cuda:3.0.0

Install natively with Ultralytics YOLO26 models (the latest NMS‑free, edge‑optimized models (Nano / Small / Medium) for object detection and instance segmentation. The integration covers the full model lifecycle: training, inference, quantization, and OpenVINO™ model export.

  • Linux / WSL2:

curl -fsSL https://raw.githubusercontent.com/open-edge-platform/geti/develop/install.sh | bash

  • Windows (PowerShell):

irm https://raw.githubusercontent.com/open-edge-platform/geti/develop/install.ps1 | iex

image

Geti Library (geti-tune) Release Notes (Formerly known as OTX)

We are pleased to announce the first public release of geti-tune, a package evolved from the OTX — OpenVINO™ Training Extensions — library. The library has been renamed and enhanced to support streamlined model fine-tuning workflows.
geti-tune provides an end-to-end stack for AI model development and optimization, enabling efficient adaptation of pretrained models to custom datasets and tasks.

The library includes several key modules that enable:

  • Multi-task support for classification, object detection, rotated detection, instance segmentation, semantic segmentation, and keypoint detection.

  • Tiling for large images across detection and segmentation tasks.

  • Multiple backend support: train with PyTorch Lightning, and export and run inference with ONNX and OpenVINO™.

  • Hardware acceleration with Intel GPUs/XPU and NVIDIA CUDA.

  • Datumaro-based data frontend with automatic format detection, including COCO, YOLO, VOC, and native formats.

  • Distributed training across multiple GPUs.

  • Mixed-precision training to reduce memory usage and increase batch size.

  • Class-incremental learning to extend existing models with new classes.

  • Deployment support for OpenVINO™ IR and ONNX formats, with inference through OpenVINO™ ModelAPI.

Key New Features and Improvements

  • Added new model families and capabilities for detection and instance segmentation, including RF-DETR and DEIMv2.

  • Upgraded the augmentation and preprocessing pipeline with pure Torch-based operations, including Kornia GPU-based augmentations integration that can improve training speed by up to 3x.

  • Added support for higher bit-depth grayscale uint16 images for medical and scientific use cases.

  • Enabled ONNX model usage in the OpenVINO™ engine for test and predict workflows, broadening runtime compatibility.

  • Expanded dataset and observability ergonomics with richer dataset introspection and per-epoch training summaries.

  • Integrated the new Datumaro design for improved flexibility and more consistent API usage across dataset import, inspection, conversion, and training workflows.

  • Improved training and inference performance, as well as recipe quality, through targeted optimizer and model-manifest tuning, notably for RTMDet and YOLOX.

  • Improved developer experience and maintainability through stronger typing, linting, testing workflows, and refined build/test recipes.

Refactoring and Bug Fixes

  • Resolved multiple export and inference correctness issues related to OpenVINO™ and ONNX, including FP16 graph validity, metadata correctness, preprocessing mismatches, and fallback behavior.

  • Fixed model-specific stability and quality issues across RF-DETR, Mask R-CNN, DEIMv2, and RTMDet-related workflows.

  • Corrected packaging and installation issues, including CPU handling and platform-specific dependency resolution.

  • Addressed data loading and multiprocessing reliability issues that affected throughput and training consistency.

  • Renamed and migrated the core package identity from OTX to geti-tune across code and interfaces.

  • Simplified model API surfaces and removed legacy entities and templates, reducing maintenance overhead.

  • Removed anomaly task support and associated exportable code paths to narrow and clarify the maintained scope.

  • Continued dependency and platform modernization, including Python baseline changes, major framework upgrades, and security-driven updates.

Source code for open source components, provided as required by license.

Assets 2
Loading