easydetect 0.1.0__py3-none-any.whl

easydetect/__init__.py

@@ -0,0 +1,44 @@
+# Apache-2.0
+"""easydetect — real-time object detection you can ship, 100% Apache-2.0.
+
+    pip install easydetect
+
+    from easydetect import Detector
+
+    model = Detector("dfine-s")                      # weights fetched from the mirror
+    results = model("photo.jpg")                     # list[Results]
+    results[0].boxes.xyxy, results[0].boxes.conf     # plain numpy
+    results[0].save()
+
+    model.train(data="data.yaml", epochs=50)         # your own dataset
+    model.val(data="data.yaml").box.map50            # COCO-style mAP
+    model.export(format="openvino", half=True)       # IR + labels.txt
+
+The detector is D-FINE (Peterande/D-FINE, Apache-2.0), a real-time DETR, in
+five sizes n/s/m/l/x; its released COCO weights load unchanged. The API,
+trainer, validator, exporter, predictor and CLI are this project's own. No AGPL
+code or weights anywhere, so this package can ship inside a product. Inference
+needs numpy/opencv/openvino/pyyaml; training adds
+``pip install "easydetect[train]"`` (torch, torchvision, scipy, onnx).
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .errors import DownloadError, EasyDetectError, ModelNotFoundError
+from .metrics import BoxMetrics, DetMetrics
+from .model import Detector
+from .results import Boxes, Results
+
+__all__ = [
+    "Detector",
+    "Results",
+    "Boxes",
+    "DetMetrics",
+    "BoxMetrics",
+    "EasyDetectError",
+    "ModelNotFoundError",
+    "DownloadError",
+    "__version__",
+]

easydetect/cli.py

@@ -0,0 +1,149 @@
+# Apache-2.0
+"""``easydetect <mode> key=value ...`` — the command line for this package.
+
+    easydetect predict model=dfine-s source=bus.jpg conf=0.5
+    easydetect train   model=dfine-s data=data.yaml epochs=100 imgsz=640
+    easydetect val     model=best.pt data=data.yaml
+    easydetect export  model=best.pt format=openvino half=true
+    easydetect track   model=best.pt source=video.mp4
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+MODES = ("predict", "track", "train", "val", "export")
+
+HELP = """easydetect — real-time object detection (D-FINE), Apache-2.0
+
+Usage:  easydetect <mode> key=value ...
+
+Modes:
+  predict   run detection on an image / folder / video / url / camera
+  track     predict and keep an id on each box across frames
+  train     train on a data.yaml dataset (images/ + labels/*.txt)
+  val       COCO-style mAP50 / mAP50-95 on the val split
+  export    write an OpenVINO IR (or ONNX) next to the checkpoint
+
+Common keys:
+  model=dfine-n|s|m|l|x|best.pt|model.xml   source=bus.jpg|dir|video.mp4|0|url
+  data=data.yaml  epochs=100  imgsz=640  batch=8  conf=0.25  device=0|cpu|AUTO
+  project=runs  name=predict  save=true  show=false  format=openvino  half=true
+
+Examples:
+  easydetect predict model=dfine-s source=bus.jpg conf=0.5
+  easydetect train   model=dfine-s data=data.yaml epochs=100
+  easydetect val     model=best.pt data=data.yaml
+  easydetect export  model=best.pt format=openvino half=true
+"""
+
+
+def parse_value(text: str) -> Any:
+    """``true`` -> True, ``3`` -> 3, ``0.5`` -> 0.5, ``0,1`` -> [0, 1], else str."""
+    low = text.lower()
+    if low in ("true", "yes"):
+        return True
+    if low in ("false", "no"):
+        return False
+    if low in ("none", "null"):
+        return None
+    for cast in (int, float):
+        try:
+            return cast(text)
+        except ValueError:
+            pass
+    stripped = text.strip("[]")
+    if "," in stripped:
+        return [parse_value(part.strip()) for part in stripped.split(",") if part.strip()]
+    return text
+
+
+def parse_args(argv: list[str]) -> tuple[str, dict[str, Any]]:
+    """-> ``(mode, overrides)``. The mode may be positional or ``mode=predict``."""
+    mode = ""
+    overrides: dict[str, Any] = {}
+    for arg in argv:
+        if "=" in arg:
+            key, _, value = arg.partition("=")
+            key = key.strip().lstrip("-")
+            if key == "mode":
+                mode = str(value)
+            else:
+                overrides[key] = parse_value(value)
+        elif not mode:
+            mode = arg
+        else:
+            raise SystemExit(f"unexpected argument {arg!r} — arguments are key=value pairs")
+    return mode, overrides
+
+
+def _take(overrides: dict[str, Any], key: str, default: Any = None) -> Any:
+    return overrides.pop(key, default)
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        print(HELP)
+        return 0
+    if argv[0] in ("-v", "--version", "version"):
+        from . import __version__
+
+        print(__version__)
+        return 0
+
+    mode, overrides = parse_args(argv)
+    if mode not in MODES:
+        print(f"unknown mode {mode!r}. Modes: {', '.join(MODES)}\n", file=sys.stderr)
+        print(HELP, file=sys.stderr)
+        return 2
+
+    from .model import Detector
+
+    model_name = _take(overrides, "model", "dfine-s")
+    device = _take(overrides, "device")
+    verbose = _take(overrides, "verbose", True)
+
+    if mode in ("predict", "track"):
+        model = Detector(model_name, device=device or "AUTO", verbose=verbose)
+        source = _take(overrides, "source")
+        if source is None:
+            print(
+                "predict needs source=… (image, folder, video, url, camera index)",
+                file=sys.stderr,
+            )
+            return 2
+        overrides.setdefault("save", True)
+        overrides["stream"] = False
+        runner = model.predict if mode == "predict" else model.track
+        results = runner(source, **overrides)
+        print(f"{len(results)} result(s)")
+        return 0
+
+    model = Detector(model_name, verbose=verbose)
+    if mode == "train":
+        data = _take(overrides, "data")
+        if data is None:
+            print("train needs data=path/to/data.yaml", file=sys.stderr)
+            return 2
+        best = model.train(data=data, device=device, **overrides)
+        print(best)
+        return 0
+    if mode == "val":
+        data = _take(overrides, "data")
+        if data is None:
+            print("val needs data=path/to/data.yaml", file=sys.stderr)
+            return 2
+        metrics = model.val(data=data, device=device, **overrides)
+        if not verbose:  # model.val() already printed the line when verbose
+            print(f"mAP50 {metrics.box.map50:.4f}  mAP50-95 {metrics.box.map:.4f}")
+        return 0
+
+    path = model.export(**overrides)
+    print(path)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

easydetect/data/__init__.py

@@ -0,0 +1 @@
+# Apache-2.0

easydetect/data/dataset.py

@@ -0,0 +1,161 @@
+# Apache-2.0
+"""Detection dataset: a data.yaml plus images/ and labels/*.txt.
+
+data.yaml:
+    path: dataset root (optional)
+    train: images dir or txt list
+    val: images dir or txt list
+    names: {0: person, ...} or [person, ...]
+Labels: <images-dir with 'images' replaced by 'labels'>/<stem>.txt
+        each line: cls cx cy w h  (normalized)
+"""
+
+import random
+from pathlib import Path
+
+import cv2
+import numpy as np
+import torch
+import yaml
+from torch.utils.data import Dataset
+
+from .labels import label_path, label_row_to_box
+
+IMG_EXT = {".jpg", ".jpeg", ".png", ".bmp", ".webp"}
+
+
+def load_data_yaml(path):
+    with open(path, encoding="utf-8") as f:
+        cfg = yaml.safe_load(f)
+    yaml_dir = Path(path).resolve().parent
+    root = Path(cfg.get("path") or yaml_dir)
+    if not root.is_absolute():
+        root = yaml_dir / root
+    if not root.exists():
+        # a dataset downloaded from elsewhere often keeps its author's path
+        # (/content/datasets/..., a Windows home folder); the yaml's own folder
+        # is the only root that can be right on this machine
+        root = yaml_dir
+    names = cfg["names"]
+    if isinstance(names, list):
+        names = {i: n for i, n in enumerate(names)}
+    names = {int(k): str(v) for k, v in names.items()}
+    return {
+        "root": root,
+        "yaml_dir": yaml_dir,
+        "train": cfg.get("train"),
+        "val": cfg.get("val"),
+        "names": names,
+        "nc": len(names),
+    }
+
+
+def _locate(root: Path, yaml_dir: Path, spec: str) -> Path:
+    """Where a train/val entry points, trying the ways data.yaml files are written.
+
+    Relative to ``path:`` first; then to the yaml itself; then with leading
+    ``../`` dropped — exports that sit beside their splits still write
+    ``train: ../train/images``.
+    """
+    spec_path = Path(spec)
+    if spec_path.is_absolute():
+        return spec_path
+    tried = [root / spec_path, yaml_dir / spec_path]
+    stripped = Path(*[part for part in spec_path.parts if part != ".."] or ["."])
+    tried.append(yaml_dir / stripped)
+    for candidate in tried:
+        if candidate.exists():
+            return candidate
+    raise FileNotFoundError(
+        f"train/val entry {spec!r} not found; tried "
+        + ", ".join(str(c) for c in dict.fromkeys(tried))
+    )
+
+
+def _list_images(root: Path, spec, yaml_dir: Path | None = None):
+    """Images for one split: a folder, a .txt list, or a list of either."""
+    if isinstance(spec, (list, tuple)):
+        files = [f for s in spec for f in _list_images(root, s, yaml_dir)]
+        return list(dict.fromkeys(files))
+    p = _locate(root, yaml_dir or root, str(spec))
+    if p.is_dir():
+        return sorted(f for f in p.rglob("*") if f.suffix.lower() in IMG_EXT)
+    if p.suffix == ".txt":
+        base = p.parent
+        out = []
+        for line in p.read_text().splitlines():
+            line = line.strip()
+            if line:
+                q = Path(line)
+                out.append(q if q.is_absolute() else base / q)
+        return out
+    raise FileNotFoundError(f"train/val entry not found: {p}")
+
+
+_label_path = label_path  # older name, kept for callers
+
+
+class DetDataset(Dataset):
+    def __init__(self, data_yaml, split="train", imgsz=640, augment=True):
+        cfg = load_data_yaml(data_yaml)
+        self.names, self.nc = cfg["names"], cfg["nc"]
+        self.imgsz = imgsz
+        self.augment = augment and split == "train"
+        if cfg[split] is None:
+            raise ValueError(
+                f"{data_yaml} has no '{split}:' entry. Add one — it may point at the "
+                f"training images, but then mAP only measures memorisation."
+            )
+        self.files = _list_images(cfg["root"], cfg[split], cfg["yaml_dir"])
+        if not self.files:
+            raise FileNotFoundError(f"no images for split '{split}'")
+
+    def __len__(self):
+        return len(self.files)
+
+    def _load_labels(self, img_file):
+        lp = _label_path(img_file)
+        if not lp.exists():
+            return np.zeros((0, 5), np.float32)
+        rows = []
+        for line in lp.read_text().splitlines():
+            row = label_row_to_box(line.split())
+            if row is not None:
+                rows.append(row)
+        return np.asarray(rows, np.float32) if rows else np.zeros((0, 5), np.float32)
+
+    def __getitem__(self, i):
+        f = self.files[i]
+        img = cv2.imread(str(f))
+        if img is None:
+            raise FileNotFoundError(f)
+        labels = self._load_labels(f)  # cls, cx, cy, w, h (normalized)
+
+        if self.augment:
+            # hflip
+            if random.random() < 0.5:
+                img = img[:, ::-1]
+                if len(labels):
+                    labels[:, 1] = 1.0 - labels[:, 1]
+            # HSV jitter
+            hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.int16)
+            hsv[..., 0] = (hsv[..., 0] + random.randint(-8, 8)) % 180
+            hsv[..., 1] = np.clip(hsv[..., 1] + random.randint(-30, 30), 0, 255)
+            hsv[..., 2] = np.clip(hsv[..., 2] + random.randint(-30, 30), 0, 255)
+            img = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
+
+        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()
+
+        target = {
+            "labels": torch.as_tensor(labels[:, 0], dtype=torch.long),
+            "boxes": torch.as_tensor(labels[:, 1:5], dtype=torch.float32),  # cxcywh 0..1
+        }
+        return tensor, target
+
+    @staticmethod
+    def collate(batch):
+        imgs = torch.stack([b[0] for b in batch])
+        targets = [b[1] for b in batch]
+        return imgs, targets

easydetect/data/labels.py

@@ -0,0 +1,48 @@
+# Apache-2.0
+"""Where a label lives, and how one line of it reads — shared by everything.
+
+The trainer reads labels, the platform writes them, the exporter packs them.
+If any two of those disagree on where ``a.jpg``'s boxes are, training runs on
+nothing and nobody is told. So there is one rule, here, and no torch import:
+the platform uses it at startup.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePath
+
+import numpy as np
+
+
+def label_path(image: str | PurePath) -> PurePath:
+    """``…/images/train/a.jpg`` -> ``…/labels/train/a.txt``.
+
+    The last folder called ``images`` becomes ``labels``; with none, the label
+    sits beside the image. Works on relative paths too, which is how an export
+    lays out a zip that the trainer will read after unpacking.
+    """
+    image = image if isinstance(image, PurePath) else Path(image)
+    parts = list(image.parts)
+    for i in range(len(parts) - 2, -1, -1):  # folders only, never the file name
+        if parts[i] == "images":
+            parts[i] = "labels"
+            return type(image)(*parts).with_suffix(".txt")
+    return image.with_suffix(".txt")
+
+
+def label_row_to_box(values: list[str]) -> list[float] | None:
+    """One label line -> ``[cls, cx, cy, w, h]``, or None for a line to skip.
+
+    ``cls cx cy w h`` is a box (a trailing sixth value, a confidence, is
+    ignored). ``cls x1 y1 x2 y2 x3 y3 ...`` is a segmentation polygon, common
+    in exported datasets; reading its first four numbers as a box would train
+    on nonsense without a single error, so it becomes its bounding box.
+    """
+    if len(values) >= 7 and len(values) % 2 == 1:
+        xy = np.asarray(values[1:], np.float32).reshape(-1, 2)
+        (x0, y0), (x1, y1) = xy.min(0), xy.max(0)
+        return [float(values[0]), float(x0 + x1) / 2, float(y0 + y1) / 2,
+                float(x1 - x0), float(y1 - y0)]
+    if len(values) >= 5:
+        return [float(v) for v in values[:5]]
+    return None

easydetect/downloads.py

@@ -0,0 +1,145 @@
+# Apache-2.0
+"""Pretrained-weight download and cache — stdlib only (urllib), cached in ~/.easydetect.
+
+``Detector("dfine-s")`` has to just work, so the first predict pulls the
+OpenVINO IR for that name from the public mirror and keeps it under
+``~/.easydetect/`` (override with ``$EASYDETECT_HOME``). The mirror base URL is
+``$EASYDETECT_ASSETS_URL``-overridable, which is also how an offline site points
+the package at an internal copy.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+from .errors import DownloadError, ModelNotFoundError
+
+#: Where the released weights live. Layout: ``<base>/<name>/<file>``.
+DEFAULT_ASSETS_URL = "https://huggingface.co/leeyunjai/easydetect/resolve/main"
+
+#: Names the mirror knows, with the spellings users type mapped onto them.
+MODEL_NAMES = ("dfine-n", "dfine-s", "dfine-m", "dfine-l", "dfine-x")
+
+_TIMEOUT = 30.0
+
+
+def normalize_name(name: str) -> str:
+    """``dfine_s`` / ``D-FINE-S`` / ``DFINE-S`` / ``dfine-s.pt`` -> ``dfine-s``."""
+    stem = str(name).strip().lower()
+    for suffix in (".pt", ".xml", ".onnx"):
+        if stem.endswith(suffix):
+            stem = stem[: -len(suffix)]
+    stem = stem.replace("_", "-")
+    return "dfine-" + stem[len("d-fine-"):] if stem.startswith("d-fine-") else stem
+
+
+def is_model_name(name: str) -> bool:
+    return normalize_name(name) in MODEL_NAMES
+
+
+def assets_url() -> str:
+    return os.environ.get("EASYDETECT_ASSETS_URL", DEFAULT_ASSETS_URL).rstrip("/")
+
+
+def cache_dir() -> Path:
+    root = Path(os.environ.get("EASYDETECT_HOME", Path.home() / ".easydetect")).expanduser()
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def read_url_bytes(url: str, timeout: float = _TIMEOUT) -> bytes:
+    """Fetch a URL into memory (used for image URLs as well as weights)."""
+    request = urllib.request.Request(url, headers={"User-Agent": "easydetect"})
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.read()
+    except urllib.error.URLError as exc:
+        raise DownloadError(f"could not fetch {url}: {exc}") from exc
+
+
+def download(url: str, dest: Path, progress: bool = True) -> Path:
+    """Download ``url`` to ``dest`` (atomically). Existing files are reused."""
+    dest = Path(dest)
+    if dest.exists() and dest.stat().st_size:
+        return dest
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dest.with_suffix(dest.suffix + ".part")
+    request = urllib.request.Request(url, headers={"User-Agent": "easydetect"})
+    try:
+        with urllib.request.urlopen(request, timeout=_TIMEOUT) as response, open(tmp, "wb") as out:
+            total = int(response.headers.get("Content-Length") or 0)
+            done = 0
+            while chunk := response.read(1 << 16):
+                out.write(chunk)
+                done += len(chunk)
+                if progress and total and sys.stderr.isatty():
+                    pct = 100 * done / total
+                    print(f"\rdownloading {dest.name} {pct:5.1f}%", end="", file=sys.stderr)
+        if progress and sys.stderr.isatty():
+            print(f"\rdownloading {dest.name}  done ", file=sys.stderr)
+    except urllib.error.HTTPError as exc:
+        tmp.unlink(missing_ok=True)
+        raise DownloadError(f"HTTP {exc.code} for {url}") from exc
+    except urllib.error.URLError as exc:
+        tmp.unlink(missing_ok=True)
+        raise DownloadError(f"could not fetch {url}: {exc}") from exc
+    shutil.move(str(tmp), str(dest))
+    return dest
+
+
+def _asset(name: str, filename: str, required: bool = True) -> Path | None:
+    dest = cache_dir() / name / filename
+    if dest.exists() and dest.stat().st_size:
+        return dest
+    url = f"{assets_url()}/{name}/{filename}"
+    try:
+        return download(url, dest)
+    except DownloadError:
+        if required:
+            raise
+        return None
+
+
+def download_ir(name: str) -> Path:
+    """Fetch ``<name>.xml`` (+ ``.bin``, + ``labels.txt``); returns the .xml path."""
+    name = normalize_name(name)
+    if name not in MODEL_NAMES:
+        raise ModelNotFoundError(_unknown_name_message(name))
+    try:
+        xml = _asset(name, f"{name}.xml")
+        _asset(name, f"{name}.bin")
+    except DownloadError as exc:
+        raise ModelNotFoundError(
+            f"'{name}' is not on the mirror yet ({exc}). Pass a .pt/.xml path, "
+            f"point $EASYDETECT_ASSETS_URL at your own copy, or train it yourself: "
+            f"Detector('{name}').train(data='data.yaml')"
+        ) from exc
+    _asset(name, "labels.txt", required=False)
+    return xml
+
+
+def download_checkpoint(name: str) -> Path:
+    """Fetch ``<name>.pt`` — the torch weights used to fine-tune or validate."""
+    name = normalize_name(name)
+    if name not in MODEL_NAMES:
+        raise ModelNotFoundError(_unknown_name_message(name))
+    try:
+        return _asset(name, f"{name}.pt")
+    except DownloadError as exc:
+        raise ModelNotFoundError(
+            f"no pretrained checkpoint for '{name}' on the mirror ({exc}). "
+            f"Training starts from an ImageNet backbone instead: "
+            f"Detector('{name}').train(data='data.yaml')"
+        ) from exc
+
+
+def _unknown_name_message(name: str) -> str:
+    return (
+        f"unknown model '{name}'. Known names: {', '.join(MODEL_NAMES)}. "
+        f"You can also pass a path to your own .pt / .xml / .onnx."
+    )

easydetect/errors.py

@@ -0,0 +1,16 @@
+# Apache-2.0
+"""Errors this package raises. Kept in one place so they are easy to catch."""
+
+from __future__ import annotations
+
+
+class EasyDetectError(Exception):
+    """Base class for every error raised by easydetect."""
+
+
+class ModelNotFoundError(EasyDetectError, FileNotFoundError):
+    """A model name could not be resolved to weights (locally or on the mirror)."""
+
+
+class DownloadError(EasyDetectError, OSError):
+    """A weight download failed."""

easydetect/exporter.py

@@ -0,0 +1,86 @@
+# Apache-2.0
+"""Export: DFINENet -> ONNX (opset 17) -> OpenVINO IR, static shape, FP16 optional."""
+
+from __future__ import annotations
+
+import copy
+import json
+import threading
+import warnings
+from pathlib import Path
+
+#: torch.onnx keeps global state while exporting ("in_onnx_export"), so two
+#: exports at once fail an assertion deep inside it. Serialise them.
+_EXPORT_LOCK = threading.Lock()
+
+
+def _write_labels(out_dir: Path, fname: str, names) -> dict[int, str]:
+    """Write ``labels.txt`` (one class per line) + ``<fname>.names.json``.
+
+    labels.txt beside the IR is how downstream runtimes (ovkit among them)
+    discover class names, so a freshly trained model answers "my-class 0.91"
+    with no extra wiring.
+    """
+    table = {int(k): str(v) for k, v in (names or {}).items()}
+    (out_dir / f"{fname}.names.json").write_text(
+        json.dumps(table, ensure_ascii=False), encoding="utf-8"
+    )
+    if table:
+        lines = [table.get(i, f"class_{i}") for i in range(max(table) + 1)]
+        (out_dir / "labels.txt").write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return table
+
+
+def export_onnx(net, names, imgsz=640, out_dir=".", fname="easydetect", half=False, verbose=True):
+    """Write ``<out_dir>/<fname>.onnx`` (plus labels). Returns the .onnx path."""
+    import torch
+
+    from .nn import DeployWrapper
+
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    onnx_path = out_dir / f"{fname}.onnx"
+
+    # the deploy form fuses the re-parameterised blocks and drops the training
+    # heads; a copy, so the caller's network can keep training
+    deployed = copy.deepcopy(net).cpu()
+    deployed = deployed.deploy() if hasattr(deployed, "deploy") else deployed.eval()
+    wrapper = DeployWrapper(deployed).eval()
+    dummy = torch.zeros(1, 3, imgsz, imgsz)
+    with _EXPORT_LOCK, warnings.catch_warnings():
+        # The graph is exported at a fixed input size on purpose, so the tracer
+        # baking shape-dependent constants (the query count) in is what we want.
+        warnings.filterwarnings("ignore", category=torch.jit.TracerWarning)
+        warnings.filterwarnings("ignore", category=UserWarning)   # shape-inference chatter
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+        torch.onnx.export(
+            wrapper,
+            dummy,
+            str(onnx_path),
+            input_names=["images"],
+            output_names=["boxes", "scores"],
+            opset_version=17,
+            dynamo=False,
+        )
+    _write_labels(out_dir, fname, names)
+    if verbose:
+        print(f"[easydetect] exported: {onnx_path}")
+    return onnx_path
+
+
+def export_openvino(net, names, imgsz=640, out_dir=".", fname="easydetect", half=False,
+                    verbose=True):
+    """Write ``<out_dir>/<fname>.xml`` (+ .bin, + labels). Returns the .xml path."""
+    import openvino as ov
+
+    out_dir = Path(out_dir)
+    onnx_path = export_onnx(
+        net, names, imgsz=imgsz, out_dir=out_dir, fname=fname, verbose=False
+    )
+    xml_path = out_dir / f"{fname}.xml"
+
+    model = ov.convert_model(str(onnx_path))
+    ov.save_model(model, str(xml_path), compress_to_fp16=half)
+    if verbose:
+        print(f"[easydetect] exported: {xml_path} ({'FP16' if half else 'FP32'})")
+    return xml_path