easydetect 0.1.2__tar.gz → 0.2.0__tar.gz

{easydetect-0.1.2 → easydetect-0.2.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.5
 Name: easydetect
-Version: 0.1.2
+Version: 0.2.0
 Summary: Easy real-time object detection you can ship: D-FINE with PyTorch training, OpenVINO inference on CPU/GPU/NPU, and a browser app to label and train. Apache-2.0 throughout.
 Project-URL: Homepage, https://github.com/themakerrobot/easydetect
 Project-URL: Source, https://github.com/themakerrobot/easydetect
 Project-URL: Documentation, https://github.com/themakerrobot/easydetect/blob/main/docs/usage.md
 Project-URL: Issues, https://github.com/themakerrobot/easydetect/issues
+Project-URL: Changelog, https://github.com/themakerrobot/easydetect/blob/main/CHANGELOG.md
 Author-email: leeyunjai <leeyunjai1982@gmail.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -23,6 +24,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Requires-Python: >=3.10
 Requires-Dist: numpy>=1.23
+Requires-Dist: onnxruntime>=1.16
 Requires-Dist: opencv-python>=4.6
 Requires-Dist: openvino>=2024.0
 Requires-Dist: pyyaml>=5.4
@@ -65,8 +67,9 @@ train and test in a browser. Apache-2.0 from the code to the model you export.
 * **Accurate for its size.** The detector is
   [D-FINE](https://github.com/Peterande/D-FINE), a real-time DETR: D-FINE-S
   scores 48.5 COCO mAP with 10M parameters.
-* **Runs on the machine you have.** OpenVINO runs the model on a CPU, an Intel
-  GPU or an Intel NPU; no CUDA needed to deploy. A GPU makes training quick.
+* **Runs on the machine you have.** OpenVINO runs it on a CPU, an Intel GPU or
+  an Intel NPU; ONNX Runtime on any CPU, a Raspberry Pi included. No CUDA
+  needed to deploy. A GPU makes training quick.
 * **No NMS to tune.** D-FINE is trained to give each object one box. The odd
   second box on the same object — one vehicle as both truck and car — is
   dropped by a fixed overlap filter (IoU 0.7, any class), so there is no
@@ -75,8 +78,18 @@ train and test in a browser. Apache-2.0 from the code to the model you export.
 ## Install
 
 ```bash
-pip install easydetect              # inference
-pip install "easydetect[train]"     # + training
+pip install easydetect              # inference: OpenVINO and ONNX Runtime
+pip install "easydetect[train]"     # + training (PyTorch)
+```
+
+Inference never needs PyTorch. Both runtimes come with the plain install and
+return the same boxes; `Detector` uses OpenVINO unless you pass
+`backend="onnxruntime"`. OpenVINO is the faster one on an Intel CPU (dfine-s at
+640 on a 4-core Xeon: 49 ms against 132 ms) and the only way to an Intel GPU or
+NPU; ONNX Runtime is the smaller one, for a box where every megabyte counts:
+
+```bash
+pip install --no-deps easydetect && pip install numpy pyyaml opencv-python onnxruntime
 ```
 
 ## Detect
@@ -222,8 +235,9 @@ easydetect export  model=best.pt format=openvino half=true
 ## What it does not do
 
 Boxes only — no segmentation, pose or classification. One training process, one
-machine; multi-GPU and distributed training are out of scope. Inference targets
-OpenVINO, so a CUDA deployment means exporting to ONNX and taking it from there.
+machine; multi-GPU and distributed training are out of scope. Inference runs on
+OpenVINO or ONNX Runtime; for a CUDA deployment, take the exported ONNX to
+TensorRT from there.
 
 ## 한국어
 
@@ -237,10 +251,16 @@ model.export(format="openvino")            # 배포용 IR + labels.txt
 ```
 
 세 줄이면 물체 검출이 됩니다. 모델은 D-FINE(실시간 DETR)이고, 코드와 가중치가
-모두 Apache-2.0이라 상용 제품이나 교육 현장에 그대로 쓸 수 있습니다. CPU만으로도
-돌고, Intel NPU·GPU에서도 같은 결과가 나옵니다. 라벨링부터 학습·추론까지
-브라우저로 하려면 `python platform/run.py`. 가중치 캐시는 `~/.easydetect/`, 사내
-미러는 `EASYDETECT_ASSETS_URL` 환경변수로 지정합니다.
+모두 Apache-2.0이라 상용 제품이나 교육 현장에 그대로 쓸 수 있습니다.
+
+설치는 두 가지입니다. `pip install easydetect`는 추론용으로 OpenVINO와 ONNX
+Runtime이 함께 들어가고 PyTorch는 없습니다. `pip install "easydetect[train]"`은
+학습까지 합니다. 기본 엔진은 OpenVINO(인텔 CPU·GPU·NPU)이고,
+`Detector("dfine-s", backend="onnxruntime")`로 ONNX Runtime(모든 CPU, 라즈베리파이
+포함)을 쓸 수 있습니다. 두 엔진의 결과는 같습니다.
+
+라벨링부터 학습·추론까지 브라우저로 하려면 `python platform/run.py`. 가중치 캐시는
+`~/.easydetect/`, 사내 미러는 `EASYDETECT_ASSETS_URL` 환경변수로 지정합니다.
 
 ## Credits
 

{easydetect-0.1.2 → easydetect-0.2.0}/README.md

@@ -25,8 +25,9 @@ train and test in a browser. Apache-2.0 from the code to the model you export.
 * **Accurate for its size.** The detector is
   [D-FINE](https://github.com/Peterande/D-FINE), a real-time DETR: D-FINE-S
   scores 48.5 COCO mAP with 10M parameters.
-* **Runs on the machine you have.** OpenVINO runs the model on a CPU, an Intel
-  GPU or an Intel NPU; no CUDA needed to deploy. A GPU makes training quick.
+* **Runs on the machine you have.** OpenVINO runs it on a CPU, an Intel GPU or
+  an Intel NPU; ONNX Runtime on any CPU, a Raspberry Pi included. No CUDA
+  needed to deploy. A GPU makes training quick.
 * **No NMS to tune.** D-FINE is trained to give each object one box. The odd
   second box on the same object — one vehicle as both truck and car — is
   dropped by a fixed overlap filter (IoU 0.7, any class), so there is no
@@ -35,8 +36,18 @@ train and test in a browser. Apache-2.0 from the code to the model you export.
 ## Install
 
 ```bash
-pip install easydetect              # inference
-pip install "easydetect[train]"     # + training
+pip install easydetect              # inference: OpenVINO and ONNX Runtime
+pip install "easydetect[train]"     # + training (PyTorch)
+```
+
+Inference never needs PyTorch. Both runtimes come with the plain install and
+return the same boxes; `Detector` uses OpenVINO unless you pass
+`backend="onnxruntime"`. OpenVINO is the faster one on an Intel CPU (dfine-s at
+640 on a 4-core Xeon: 49 ms against 132 ms) and the only way to an Intel GPU or
+NPU; ONNX Runtime is the smaller one, for a box where every megabyte counts:
+
+```bash
+pip install --no-deps easydetect && pip install numpy pyyaml opencv-python onnxruntime
 ```
 
 ## Detect
@@ -182,8 +193,9 @@ easydetect export  model=best.pt format=openvino half=true
 ## What it does not do
 
 Boxes only — no segmentation, pose or classification. One training process, one
-machine; multi-GPU and distributed training are out of scope. Inference targets
-OpenVINO, so a CUDA deployment means exporting to ONNX and taking it from there.
+machine; multi-GPU and distributed training are out of scope. Inference runs on
+OpenVINO or ONNX Runtime; for a CUDA deployment, take the exported ONNX to
+TensorRT from there.
 
 ## 한국어
 
@@ -197,10 +209,16 @@ model.export(format="openvino")            # 배포용 IR + labels.txt
 ```
 
 세 줄이면 물체 검출이 됩니다. 모델은 D-FINE(실시간 DETR)이고, 코드와 가중치가
-모두 Apache-2.0이라 상용 제품이나 교육 현장에 그대로 쓸 수 있습니다. CPU만으로도
-돌고, Intel NPU·GPU에서도 같은 결과가 나옵니다. 라벨링부터 학습·추론까지
-브라우저로 하려면 `python platform/run.py`. 가중치 캐시는 `~/.easydetect/`, 사내
-미러는 `EASYDETECT_ASSETS_URL` 환경변수로 지정합니다.
+모두 Apache-2.0이라 상용 제품이나 교육 현장에 그대로 쓸 수 있습니다.
+
+설치는 두 가지입니다. `pip install easydetect`는 추론용으로 OpenVINO와 ONNX
+Runtime이 함께 들어가고 PyTorch는 없습니다. `pip install "easydetect[train]"`은
+학습까지 합니다. 기본 엔진은 OpenVINO(인텔 CPU·GPU·NPU)이고,
+`Detector("dfine-s", backend="onnxruntime")`로 ONNX Runtime(모든 CPU, 라즈베리파이
+포함)을 쓸 수 있습니다. 두 엔진의 결과는 같습니다.
+
+라벨링부터 학습·추론까지 브라우저로 하려면 `python platform/run.py`. 가중치 캐시는
+`~/.easydetect/`, 사내 미러는 `EASYDETECT_ASSETS_URL` 환경변수로 지정합니다.
 
 ## Credits
 

{easydetect-0.1.2 → easydetect-0.2.0}/easydetect/__init__.py

@@ -24,7 +24,7 @@ needs numpy/opencv/openvino/pyyaml; training adds
 
 from __future__ import annotations
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 from .errors import DownloadError, EasyDetectError, ModelNotFoundError
 from .metrics import BoxMetrics, DetMetrics

easydetect-0.2.0/easydetect/data/augment.py

@@ -0,0 +1,207 @@
+# Apache-2.0
+"""Training-time augmentation for boxes: the recipe D-FINE trains with.
+
+Photometric jitter, a random zoom-out onto a larger canvas, an IoU-constrained
+random crop, and a horizontal flip — the steps of D-FINE's configs with the
+probabilities and ranges they use (torchvision's defaults), written here in
+NumPy/OpenCV. One difference: the zoom-out canvas is the picture's mean colour
+rather than black, so the border is not a cue that says "zoomed".
+Zoom-out makes objects small and crop makes them large, so a model sees each
+class at many sizes and positions instead of only the framing the photos had.
+
+Boxes are pixel ``xyxy`` float arrays in the original picture's coordinates;
+the geometry moves a rectangle over the picture and renders it once, at the end.
+"""
+
+from __future__ import annotations
+
+import random
+
+import cv2
+import numpy as np
+
+ZOOM_OUT_P, ZOOM_OUT_MAX = 0.5, 4.0          # canvas up to 4× the image, half the time
+CROP_P = 0.8
+CROP_MIN_IOUS = (0.0, 0.1, 0.3, 0.5, 0.7, 0.9, None)   # None: keep the whole image
+CROP_SCALE, CROP_ASPECT, CROP_TRIES = (0.3, 1.0), (0.5, 2.0), 40
+PHOTO_P = 0.5
+
+DESCRIPTION = [
+    f"photometric jitter (brightness, contrast, saturation, hue; p={PHOTO_P} each)",
+    f"zoom-out onto a canvas up to {ZOOM_OUT_MAX:g}× (p={ZOOM_OUT_P})",
+    f"IoU-constrained random crop, {CROP_SCALE[0]:g}–{CROP_SCALE[1]:g} of each side (p={CROP_P})",
+    "horizontal flip (p=0.5)",
+]
+
+
+_LEVELS = np.arange(256, dtype=np.float32)
+
+
+def photometric(img: np.ndarray) -> np.ndarray:
+    """Brightness, contrast, saturation and hue, each on its own coin flip.
+
+    Each is a per-value mapping, so each is a 256-entry table: brightness
+    and contrast fold into one table for all three channels, saturation and
+    hue into tables for the S and H planes.
+    """
+    brighten, stretch = random.random() < PHOTO_P, random.random() < PHOTO_P
+    if brighten or stretch:
+        table = _LEVELS * (random.uniform(0.875, 1.125) if brighten else 1.0)   # brightness
+        if stretch:                                      # contrast ×0.5–1.5 about the mean grey
+            grey = float(np.clip(table[cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)], 0, 255).mean())
+            table = grey + (np.clip(table, 0, 255) - grey) * random.uniform(0.5, 1.5)
+        img = cv2.LUT(img, np.clip(table, 0, 255).astype(np.uint8))
+    saturate, shift = random.random() < PHOTO_P, random.random() < PHOTO_P
+    if saturate or shift:
+        h, s, v = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
+        if saturate:                                     # saturation ×0.5–1.5
+            s = cv2.LUT(s, np.clip(_LEVELS * random.uniform(0.5, 1.5), 0, 255).astype(np.uint8))
+        if shift:                                        # hue ±0.05 of the circle (OpenCV: 0–180)
+            h = cv2.LUT(h, ((_LEVELS + random.uniform(-9, 9)) % 180).astype(np.uint8))
+        img = cv2.cvtColor(cv2.merge((h, s, v)), cv2.COLOR_HSV2BGR)
+    return img
+
+
+def zoom_out(view: np.ndarray) -> np.ndarray:
+    """Widen the view onto a canvas up to 4x the picture, the picture somewhere inside.
+
+    Nothing is drawn here: ``view`` is the rectangle, in the picture's own
+    pixel coordinates, that will become the output. The canvas outside the
+    picture is filled when the view is finally rendered.
+    """
+    if random.random() >= ZOOM_OUT_P:
+        return view
+    w, h = view[2] - view[0], view[3] - view[1]
+    s = random.uniform(1.0, ZOOM_OUT_MAX)
+    cw, ch = int(w * s), int(h * s)
+    left, top = random.randint(0, int(cw - w)), random.randint(0, int(ch - h))
+    return np.array([view[0] - left, view[1] - top, view[0] - left + cw, view[1] - top + ch],
+                    np.float32)
+
+
+def _iou(region: np.ndarray, boxes: np.ndarray) -> np.ndarray:
+    x1 = np.maximum(region[0], boxes[:, 0])
+    y1 = np.maximum(region[1], boxes[:, 1])
+    x2 = np.minimum(region[2], boxes[:, 2])
+    y2 = np.minimum(region[3], boxes[:, 3])
+    inter = np.clip(x2 - x1, 0, None) * np.clip(y2 - y1, 0, None)
+    area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    region_area = (region[2] - region[0]) * (region[3] - region[1])
+    return inter / np.maximum(area + region_area - inter, 1e-9)
+
+
+def iou_crop(view: np.ndarray, boxes: np.ndarray,
+             classes: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Narrow the view to a region that overlaps some box by at least a random IoU.
+
+    Boxes whose centre falls outside the region are dropped; the rest are
+    clipped to it. A picture with no boxes (a background frame) takes any
+    region. When no region qualifies, the view stays as it was.
+    """
+    if random.random() >= CROP_P:
+        return view, boxes, classes
+    w, h = view[2] - view[0], view[3] - view[1]
+    min_iou = random.choice(CROP_MIN_IOUS)
+    if min_iou is None:
+        return view, boxes, classes
+    for _ in range(CROP_TRIES):
+        cw = w * random.uniform(*CROP_SCALE)
+        ch = h * random.uniform(*CROP_SCALE)
+        if not CROP_ASPECT[0] <= cw / ch <= CROP_ASPECT[1]:
+            continue
+        cw, ch = max(int(cw), 1), max(int(ch), 1)
+        left = view[0] + random.randint(0, int(w - cw))
+        top = view[1] + random.randint(0, int(h - ch))
+        region = np.array([left, top, left + cw, top + ch], np.float32)
+        if len(boxes):
+            if _iou(region, boxes).max() < min_iou:
+                continue
+            cx, cy = (boxes[:, 0] + boxes[:, 2]) / 2, (boxes[:, 1] + boxes[:, 3]) / 2
+            inside = (cx > region[0]) & (cx < region[2]) & (cy > region[1]) & (cy < region[3])
+            if not inside.any():
+                continue
+            kept = boxes[inside].copy()
+            kept[:, [0, 2]] = np.clip(kept[:, [0, 2]], region[0], region[2])
+            kept[:, [1, 3]] = np.clip(kept[:, [1, 3]], region[1], region[3])
+            boxes, classes = kept, classes[inside]
+        return region, boxes, classes
+    return view, boxes, classes
+
+
+def render(img: np.ndarray, view: np.ndarray, size: tuple[int, int],
+           flip: bool) -> np.ndarray:
+    """Draw ``view`` (picture coordinates, may reach past the picture) at ``size``.
+
+    One affine warp straight to the output, so a 4x zoom-out never builds a
+    canvas 4x the photo. Outside the picture is its mean colour. A big
+    shrink goes through an area resize first, so fine detail averages
+    instead of aliasing.
+    """
+    h, w = img.shape[:2]
+    out_w, out_h = size
+    sx, sy = out_w / (view[2] - view[0]), out_h / (view[3] - view[1])
+    inside = view[0] >= 0 and view[1] >= 0 and view[2] <= w and view[3] <= h
+    if inside and not flip and view[0] == 0 and view[1] == 0 and view[2] == w and view[3] == h:
+        return cv2.resize(img, (out_w, out_h))
+    src, fx, fy = img, 1.0, 1.0
+    if max(sx, sy) < 0.5:                       # shrinking hard: average first
+        nw, nh = max(1, round(w * sx * 2)), max(1, round(h * sy * 2))
+        src = cv2.resize(img, (nw, nh), interpolation=cv2.INTER_AREA)
+        fx, fy = nw / w, nh / h
+    ax, ay = sx / fx, sy / fy
+    if flip:
+        m = np.array([[-ax, 0, view[2] * sx], [0, ay, -view[1] * sy]], np.float32)
+    else:
+        m = np.array([[ax, 0, -view[0] * sx], [0, ay, -view[1] * sy]], np.float32)
+    fill = cv2.mean(img)[:3]
+    return cv2.warpAffine(src, m, (out_w, out_h), flags=cv2.INTER_LINEAR,
+                          borderMode=cv2.BORDER_CONSTANT, borderValue=fill)
+
+
+def apply(img: np.ndarray, labels: np.ndarray, strong: bool = True,
+          size: int | None = None, min_side: float = 1.0) -> tuple[np.ndarray, np.ndarray]:
+    """Augment one picture and its ``cls cx cy w h`` (normalised) labels.
+
+    ``size`` renders the result square at that many pixels (what training
+    wants, and the cheap way); ``None`` keeps the view's own pixel size.
+    ``strong=False`` keeps only the flip — what the last epochs train on, as
+    in D-FINE, so the model settles on pictures framed like the ones it will
+    see. ``min_side`` drops boxes thinner than that many output pixels.
+    Colour jitter runs last, on the small output: it does not care where the
+    pixels came from, and there are far fewer of them there.
+    """
+    h, w = img.shape[:2]
+    classes = labels[:, 0].copy()
+    boxes = np.empty((len(labels), 4), np.float32)
+    boxes[:, 0] = (labels[:, 1] - labels[:, 3] / 2) * w
+    boxes[:, 1] = (labels[:, 2] - labels[:, 4] / 2) * h
+    boxes[:, 2] = (labels[:, 1] + labels[:, 3] / 2) * w
+    boxes[:, 3] = (labels[:, 2] + labels[:, 4] / 2) * h
+
+    view = np.array([0, 0, w, h], np.float32)
+    if strong:
+        view = zoom_out(view)
+        view, boxes, classes = iou_crop(view, boxes, classes)
+    flip = random.random() < 0.5
+
+    vw, vh = view[2] - view[0], view[3] - view[1]
+    out_size = (size, size) if size else (max(1, round(float(vw))), max(1, round(float(vh))))
+    img = render(img, view, out_size, flip)
+    if strong:
+        img = photometric(img)
+
+    # boxes into the output: relative to the view, mirrored if flipped
+    rel = boxes - np.array([view[0], view[1], view[0], view[1]], np.float32)
+    if flip:
+        rel[:, [0, 2]] = vw - rel[:, [2, 0]]
+    rel /= np.array([vw, vh, vw, vh], np.float32)
+    ow, oh = out_size
+    keep = ((rel[:, 2] - rel[:, 0]) * ow >= min_side) & ((rel[:, 3] - rel[:, 1]) * oh >= min_side)
+    rel, classes = rel[keep], classes[keep]
+    out = np.empty((len(rel), 5), np.float32)
+    out[:, 0] = classes
+    out[:, 1] = (rel[:, 0] + rel[:, 2]) / 2
+    out[:, 2] = (rel[:, 1] + rel[:, 3]) / 2
+    out[:, 3] = rel[:, 2] - rel[:, 0]
+    out[:, 4] = rel[:, 3] - rel[:, 1]
+    return img, out

{easydetect-0.1.2 → easydetect-0.2.0}/easydetect/data/dataset.py

@@ -134,10 +134,10 @@ class DetDataset(Dataset):
             raise FileNotFoundError(f)
         labels = self._load_labels(f)  # cls, cx, cy, w, h (normalized)
 
-        if self.augment:
-            img, labels = aug.apply(img, labels, strong=self.strong)
-
-        img = cv2.resize(img, (self.imgsz, self.imgsz))  # plain resize, as D-FINE trains
+        if self.augment:   # rendered straight at imgsz x imgsz
+            img, labels = aug.apply(img, labels, strong=self.strong, size=self.imgsz)
+        else:
+            img = cv2.resize(img, (self.imgsz, self.imgsz))  # plain resize, as D-FINE trains
         img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
         tensor = torch.from_numpy(img.transpose(2, 0, 1)).contiguous()
 

{easydetect-0.1.2 → easydetect-0.2.0}/easydetect/downloads.py

@@ -123,6 +123,22 @@ def download_ir(name: str) -> Path:
     return xml
 
 
+def download_onnx(name: str) -> Path:
+    """Fetch ``<name>.onnx`` (+ ``labels.txt``) — what ONNX Runtime runs."""
+    name = normalize_name(name)
+    if name not in MODEL_NAMES:
+        raise ModelNotFoundError(_unknown_name_message(name))
+    try:
+        onnx = _asset(name, f"{name}.onnx")
+    except DownloadError as exc:
+        raise ModelNotFoundError(
+            f"'{name}'.onnx is not on the mirror ({exc}). Install openvino to use the IR, "
+            f"or export one: Detector('{name}').export(format='onnx')"
+        ) from exc
+    _asset(name, "labels.txt", required=False)
+    return onnx
+
+
 def download_checkpoint(name: str) -> Path:
     """Fetch ``<name>.pt`` — the torch weights used to fine-tune or validate."""
     name = normalize_name(name)

{easydetect-0.1.2 → easydetect-0.2.0}/easydetect/model.py

@@ -63,13 +63,20 @@ class Detector:
         verbose: bool = True,
         precision: str | None = None,
         pretrained: bool = True,
+        backend: str | None = None,
     ) -> None:
         """``pretrained=False`` starts training from an ImageNet backbone
         instead of the mirror's COCO weights — for domains COCO says nothing
-        about, or for a clean baseline."""
+        about, or for a clean baseline.
+
+        ``backend`` picks the runtime: ``"openvino"`` (CPU, Intel GPU, NPU;
+        reads ``.xml`` and ``.onnx``) or ``"onnxruntime"`` (CPU; ``.onnx``
+        only, the lighter install). Left out, OpenVINO is used when it is
+        installed and ONNX Runtime otherwise."""
         self.model_name = str(model)
         self.device = device
         self.precision = precision
+        self.backend = backend
         self.pretrained = pretrained
         self.verbose = verbose
         self.task = "detect"
@@ -78,7 +85,7 @@ class Detector:
         self.ckpt: dict | None = None
         self.variant: str | None = None
         self.ckpt_path: Path | None = None
-        self.predictor = None  # OVPredictor (lazy)
+        self.predictor = None  # OVPredictor or ORTPredictor (lazy)
         self.ir_path: Path | None = None
         self.tracker = None
 
@@ -251,30 +258,43 @@ class Detector:
                 _close_windows()
 
     def _ensure_predictor(self, device: str | None = None, imgsz: int | None = None):
-        """Compile (downloading or exporting first, if needed) the OpenVINO model."""
-        from .predictor import OVPredictor
+        """Load the model on its runtime (downloading or exporting first, if needed)."""
+        from .predictor import ORTPredictor, OVPredictor, installed, pick_backend
 
         device = device or self.device
+        if (self.ir_path is not None and self.ir_path.suffix.lower() == ".xml"
+                and self.backend != "openvino" and not installed("openvino")
+                and self.ir_path.with_suffix(".onnx").exists()):
+            # every export writes the .onnx beside the .xml: without OpenVINO, run that
+            self.ir_path = self.ir_path.with_suffix(".onnx")
+        backend = pick_backend(self.backend, self.ir_path, device)
         if (
             self.predictor is not None
+            and self.predictor.backend == backend
             and self.predictor.device == device
             and self.predictor.precision == self.precision
             and (imgsz is None or self.predictor.imgsz == imgsz)
         ):
             return self.predictor
 
+        wanted = ".xml" if backend == "openvino" else ".onnx"
+        if self.ir_path is not None and self.ir_path.suffix.lower() not in (wanted, ".onnx"):
+            self.ir_path = None             # an .xml met a runtime that cannot read it
         if self.ir_path is None:
             if self.net is not None:
-                self.ir_path = self.export(out_dir=self._cache_export_dir(), verbose=self.verbose)
-            else:
+                fmt = "openvino" if backend == "openvino" else "onnx"
+                self.ir_path = self.export(format=fmt, out_dir=self._cache_export_dir(),
+                                           verbose=self.verbose)
+            elif backend == "openvino":
                 self.ir_path = downloads.download_ir(self.model_name)
-        self.predictor = OVPredictor(
-            self.ir_path,
-            device=device,
-            imgsz=imgsz,
-            names=self.names or None,
-            precision=self.precision,
-        )
+            else:
+                self.ir_path = downloads.download_onnx(self.model_name)
+        if backend == "openvino":
+            self.predictor = OVPredictor(self.ir_path, device=device, imgsz=imgsz,
+                                         names=self.names or None, precision=self.precision)
+        else:
+            self.predictor = ORTPredictor(self.ir_path, device=device, imgsz=imgsz,
+                                          names=self.names or None, precision=self.precision)
         if not self.names:
             self.names = self.predictor.names
         return self.predictor