ovkit 0.1.2__tar.gz → 0.3.0__tar.gz

{ovkit-0.1.2 → ovkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ovkit
-Version: 0.1.2
+Version: 0.3.0
 Summary: A simple Python inference API for OpenVINO: one import, one Model class, clean Results — with AUTO/NPU, async, and INT8.
 Project-URL: Homepage, https://github.com/leeyunjai82/ovkit
 Project-URL: Documentation, https://leeyunjai82.github.io/ovkit/
@@ -28,8 +28,12 @@ Requires-Dist: pyyaml>=6.0
 Provides-Extra: all
 Requires-Dist: anomalib; extra == 'all'
 Requires-Dist: nncf; extra == 'all'
+Requires-Dist: onnx; extra == 'all'
 Requires-Dist: openvino-genai; extra == 'all'
 Requires-Dist: optimum-intel; extra == 'all'
+Requires-Dist: scipy; extra == 'all'
+Requires-Dist: torch>=2.0; extra == 'all'
+Requires-Dist: torchvision>=0.15; extra == 'all'
 Provides-Extra: anomaly
 Requires-Dist: anomalib; extra == 'anomaly'
 Provides-Extra: dev
@@ -39,8 +43,15 @@ Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: genai
 Requires-Dist: openvino-genai; extra == 'genai'
 Requires-Dist: optimum-intel; extra == 'genai'
+Provides-Extra: hand
+Requires-Dist: mediapipe; extra == 'hand'
 Provides-Extra: quant
 Requires-Dist: nncf; extra == 'quant'
+Provides-Extra: train
+Requires-Dist: onnx; extra == 'train'
+Requires-Dist: scipy; extra == 'train'
+Requires-Dist: torch>=2.0; extra == 'train'
+Requires-Dist: torchvision>=0.15; extra == 'train'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -69,14 +80,36 @@ ready models — with `AUTO`/`NPU`/`GPU` devices, async throughput, and INT8.
 ```python
 from ovkit import Model
 
-r = Model("detect")("image.jpg")[0]   # download -> convert -> cache -> run
-r.save("out.jpg")                     # boxes drawn; r.boxes.xyxy / .conf / .cls
+r = Model("detect", "image.jpg")      # download -> convert -> cache -> run
+print(r)                              # 2x person, car
+r.save("out.jpg")                     # the boxes drawn on the photo
+```
+
+One call fits every input — and Korean names work too:
+
+```python
+r = Model("얼굴분석", "group.jpg")      # == Model("face_analyze", ...)
+for row in r.found:                    # [{'name': '사람', 'name_en': 'person',
+    print(row["name"], row["pos"])     #   'score': 0.93, 'box': [...], 'pos': '왼쪽 위'}]
+
+for r in Model("track", 0):            # webcam / video / "mic" -> a stream
+    print(r, r.elapsed_ms, r.device)   # 2x person (#1, #4) 14.2 GPU
+```
+
+The same call also runs whole **capabilities** — several models chained into one
+answer, so you never have to crop, chain and stitch by hand:
+
+```python
+r = Model("face_analyze", "group.jpg")
+print(r)                # 2 faces: age 31 · male 98% · happy 92%, age 27 · female 95% · neutral 88%
 ```
 
 Or without writing Python at all:
 
 ```bash
+ovkit gui                             # a window: pick a capability, point it at your webcam
 ovkit run detect image.jpg            # prints results, saves image_out.jpg
+ovkit capabilities                    # what Model(name) can answer
 ```
 
 ## Install
@@ -94,9 +127,89 @@ python -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\act
 pip install -e ".[dev]"
 ```
 
+## Capabilities
+
+A capability name gives you the answer, not the plumbing. Each one chains a
+detector with the models that describe what it found — same `Model(...)` call,
+same `Results`, and it takes the same sources (path, ndarray, folder, video,
+camera index).
+
+| `Model(...)` | Answers | Chains |
+| ------------ | ------- | ------ |
+| `scene` | `2 people (1 happy) · a laptop and a cup · floor 47%` | detection + segmentation + faces |
+| `face_analyze` | `2 faces: age 31 · male 98% · happy 92%, ...` | face detection + age/gender + emotion (+ head pose, landmarks) |
+| `person_analyze` | `3 people: male 0.98 · long pants 0.95 · bag 0.71, ...` | person detection + attributes |
+| `vehicle_analyze` | `2 vehicles: type: car (0.98) · color: black (0.83), ...` | vehicle detection + type/colour |
+| `read_text` | `'STOP AHEAD'` — every word, in reading order | text detection + text recognition |
+| `read_plate` | `2 vehicles: black car — 12GA3456, ...` | plate detection + text recognition + vehicle attributes |
+| `track` | `2x person (#1, #4)` — ids stable across frames | detection + IoU association |
+| `drowsiness` | `EYES CLOSED 1.4s — drowsy` | face + landmarks + eye state + head pose, **over time** |
+| `gesture` | `thumb up 0.94` | sign-language model over a rolling 8-frame clip |
+| `gaze` | `1 face: looking right and slightly up` | face detection + landmarks + head pose + gaze |
+| `attention` | `1 person looking at: laptop` | gaze + object detection (ray-cast into the boxes) |
+| `anonymize` | the picture with every face pixelated | face (and plate) detection + redaction |
+| `face_match` | `('yunjai', 0.81)` — who this is | embedding + cosine matching against your gallery |
+| `count` | `pencil 3 · cup 1` (optionally one kind only) | detection + per-kind tally |
+| `posture` | `neck 32° — sit up (6s)` | pose + neck angle **over time** |
+| `exercise` | `squat x 12 (down)` | pose + joint-angle hysteresis (squat, push-up) |
+| `attendance` | `present 24/26` + `roll.csv` | face detection + roster matching |
+| `teach` | your own classes, from example photos | embedding + cosine k-NN (5 modes) |
+
+```python
+from ovkit import Model, list_pipelines
+
+list_pipelines()                                    # every capability, described
+Model("read_text")("sign.jpg")[0].text              # 'STOP AHEAD'
+Model("track")(0)                                   # webcam, ids kept across frames
+Model("face_analyze", attributes=("age_gender",))   # configure what runs
+```
+
+Aliases: `ocr`, `anpr`, `blur`, `driver`, `describe`, `faces`, `people`, `vehicle`, `tracking`, `reid`.
+
+## Teach your own AI (no GPU)
+
+A Teachable Machine in five lines — an embedding model turns examples into
+vectors, new inputs match the nearest ones. Five modes: `photo` (default),
+`face` (expressions), `hand` (needs `ovkit[hand]`), `upper`, `body`:
+
+```python
+ai = Model("teach")                       # or Model("가르치기")
+ai.learn("can", "photos/cans/")           # a folder per thing to recognise
+ai.learn("bottle", "photos/bottles/")
+print(ai.guess("new_photo.jpg"))          # ('can', 0.93)
+print(ai.score("test_photos/"))           # accuracy + what it confuses
+ai.save("recycling")                      # -> Documents/ovkit/recycling.json
+for r in ai.predict(0, stream=True): ...  # webcam over YOUR classes
+```
+
+Korean method names work too: `배우기`, `맞혀봐`, `점수`, `저장`. Collect
+examples with the webcam: `from ovkit.pipelines.teach import collect; collect("가위", 30)`.
+
+## Train your own detector
+
+RT-DETR, trainable, Apache-2.0 end to end — an Ultralytics-style workflow with
+no AGPL code or weights anywhere (`pip install "ovkit[train]"`):
+
+```python
+from ovkit import RTDETR
+
+model = RTDETR("rtdetr-r18")                 # or RTDETR("best.pt") to resume
+model.train(data="data.yaml", epochs=100)    # the YOLO-format labels you already have
+model.val(data="data.yaml")                  # mAP50 / mAP50-95
+model.export(half=True)                      # -> IR + labels.txt
+
+r = model("bus.jpg", conf=0.5)               # ovkit Results: print(r), r.found, r.save()
+```
+
+The exported IR drops straight into `Model("path/to/rtdetr-r18.xml")` — the
+`labels.txt` written next to it means your classes answer by name. CLI:
+`ovkit train --data data.yaml`, `ovkit val`, `ovkit export`.
+`ovkit capabilities` prints the list; **`ovkit gui` opens a window** where you can
+click through them against your webcam or a picture.
+
 ## Supported tasks
 
-Every task below runs end-to-end through the same 3 lines — swap the alias:
+Every single-model task below runs end-to-end through the same 3 lines — swap the alias:
 
 | Task | Alias | Output | Example |
 | ---- | ----- | ------ | ------- |
@@ -106,6 +219,7 @@ Every task below runs end-to-end through the same 3 lines — swap the alias:
 | Pose / landmarks | `pose`, `face_landmarks` | `r.keypoints` | [pose.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/pose.py) |
 | Face analysis | `age_gender`, `emotion`, `head_pose`, `face_reid` | `r.text` (e.g. `"age 31 · male 98%"`) | [face_analysis.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/face_analysis.py) |
 | OCR | `text_recognition` | `r.text` | [ocr.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/ocr.py) |
+| Tracking / matching | `track`, `face_match` | `r.track_ids` · `(label, score)` | [track.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/track.py) / [face_match.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/face_match.py) |
 | Super-resolution | `super_resolution` | upscaled image via `r.plot()` | [super_resolution.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/super_resolution.py) |
 | LLM / STT (GenAI) | `llm`, `stt` | generated text | [llm.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/llm.py) / [stt.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/stt.py) |
 | NLP / audio / time series | `qa`, `translation`, `noise_suppression`, `time_series` | tensors via `model.infer()` | [denoise_audio.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/denoise_audio.py) |
@@ -174,7 +288,10 @@ control for any model: `model.infer({name: tensor})` with `model.inputs`.
 | `r.boxes` | `xyxy`, `xywh`, `conf`, `cls` |
 | `r.masks` / `r.keypoints` / `r.probs` | masks · `[x,y,conf]` · `top1`/`top5` |
 | `r.text` | decoded text (OCR, face attributes) |
+| `r.labels` / `r.track_ids` | per-box label a pipeline wrote · per-box track id |
 | `r.tensors` | raw `{name: ndarray}` |
+| `r.summary()` | the whole result as one readable line |
+| `r.crop(i)` / `r.to_dict()` / `r.to_json()` | cut a box out · plain Python · JSON |
 | `r.plot()` / `r.save(path)` | annotated image (or the model's output image) |
 
 </details>

{ovkit-0.1.2 → ovkit-0.3.0}/README.md

@@ -24,14 +24,36 @@ ready models — with `AUTO`/`NPU`/`GPU` devices, async throughput, and INT8.
 ```python
 from ovkit import Model
 
-r = Model("detect")("image.jpg")[0]   # download -> convert -> cache -> run
-r.save("out.jpg")                     # boxes drawn; r.boxes.xyxy / .conf / .cls
+r = Model("detect", "image.jpg")      # download -> convert -> cache -> run
+print(r)                              # 2x person, car
+r.save("out.jpg")                     # the boxes drawn on the photo
+```
+
+One call fits every input — and Korean names work too:
+
+```python
+r = Model("얼굴분석", "group.jpg")      # == Model("face_analyze", ...)
+for row in r.found:                    # [{'name': '사람', 'name_en': 'person',
+    print(row["name"], row["pos"])     #   'score': 0.93, 'box': [...], 'pos': '왼쪽 위'}]
+
+for r in Model("track", 0):            # webcam / video / "mic" -> a stream
+    print(r, r.elapsed_ms, r.device)   # 2x person (#1, #4) 14.2 GPU
+```
+
+The same call also runs whole **capabilities** — several models chained into one
+answer, so you never have to crop, chain and stitch by hand:
+
+```python
+r = Model("face_analyze", "group.jpg")
+print(r)                # 2 faces: age 31 · male 98% · happy 92%, age 27 · female 95% · neutral 88%
 ```
 
 Or without writing Python at all:
 
 ```bash
+ovkit gui                             # a window: pick a capability, point it at your webcam
 ovkit run detect image.jpg            # prints results, saves image_out.jpg
+ovkit capabilities                    # what Model(name) can answer
 ```
 
 ## Install
@@ -49,9 +71,89 @@ python -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\act
 pip install -e ".[dev]"
 ```
 
+## Capabilities
+
+A capability name gives you the answer, not the plumbing. Each one chains a
+detector with the models that describe what it found — same `Model(...)` call,
+same `Results`, and it takes the same sources (path, ndarray, folder, video,
+camera index).
+
+| `Model(...)` | Answers | Chains |
+| ------------ | ------- | ------ |
+| `scene` | `2 people (1 happy) · a laptop and a cup · floor 47%` | detection + segmentation + faces |
+| `face_analyze` | `2 faces: age 31 · male 98% · happy 92%, ...` | face detection + age/gender + emotion (+ head pose, landmarks) |
+| `person_analyze` | `3 people: male 0.98 · long pants 0.95 · bag 0.71, ...` | person detection + attributes |
+| `vehicle_analyze` | `2 vehicles: type: car (0.98) · color: black (0.83), ...` | vehicle detection + type/colour |
+| `read_text` | `'STOP AHEAD'` — every word, in reading order | text detection + text recognition |
+| `read_plate` | `2 vehicles: black car — 12GA3456, ...` | plate detection + text recognition + vehicle attributes |
+| `track` | `2x person (#1, #4)` — ids stable across frames | detection + IoU association |
+| `drowsiness` | `EYES CLOSED 1.4s — drowsy` | face + landmarks + eye state + head pose, **over time** |
+| `gesture` | `thumb up 0.94` | sign-language model over a rolling 8-frame clip |
+| `gaze` | `1 face: looking right and slightly up` | face detection + landmarks + head pose + gaze |
+| `attention` | `1 person looking at: laptop` | gaze + object detection (ray-cast into the boxes) |
+| `anonymize` | the picture with every face pixelated | face (and plate) detection + redaction |
+| `face_match` | `('yunjai', 0.81)` — who this is | embedding + cosine matching against your gallery |
+| `count` | `pencil 3 · cup 1` (optionally one kind only) | detection + per-kind tally |
+| `posture` | `neck 32° — sit up (6s)` | pose + neck angle **over time** |
+| `exercise` | `squat x 12 (down)` | pose + joint-angle hysteresis (squat, push-up) |
+| `attendance` | `present 24/26` + `roll.csv` | face detection + roster matching |
+| `teach` | your own classes, from example photos | embedding + cosine k-NN (5 modes) |
+
+```python
+from ovkit import Model, list_pipelines
+
+list_pipelines()                                    # every capability, described
+Model("read_text")("sign.jpg")[0].text              # 'STOP AHEAD'
+Model("track")(0)                                   # webcam, ids kept across frames
+Model("face_analyze", attributes=("age_gender",))   # configure what runs
+```
+
+Aliases: `ocr`, `anpr`, `blur`, `driver`, `describe`, `faces`, `people`, `vehicle`, `tracking`, `reid`.
+
+## Teach your own AI (no GPU)
+
+A Teachable Machine in five lines — an embedding model turns examples into
+vectors, new inputs match the nearest ones. Five modes: `photo` (default),
+`face` (expressions), `hand` (needs `ovkit[hand]`), `upper`, `body`:
+
+```python
+ai = Model("teach")                       # or Model("가르치기")
+ai.learn("can", "photos/cans/")           # a folder per thing to recognise
+ai.learn("bottle", "photos/bottles/")
+print(ai.guess("new_photo.jpg"))          # ('can', 0.93)
+print(ai.score("test_photos/"))           # accuracy + what it confuses
+ai.save("recycling")                      # -> Documents/ovkit/recycling.json
+for r in ai.predict(0, stream=True): ...  # webcam over YOUR classes
+```
+
+Korean method names work too: `배우기`, `맞혀봐`, `점수`, `저장`. Collect
+examples with the webcam: `from ovkit.pipelines.teach import collect; collect("가위", 30)`.
+
+## Train your own detector
+
+RT-DETR, trainable, Apache-2.0 end to end — an Ultralytics-style workflow with
+no AGPL code or weights anywhere (`pip install "ovkit[train]"`):
+
+```python
+from ovkit import RTDETR
+
+model = RTDETR("rtdetr-r18")                 # or RTDETR("best.pt") to resume
+model.train(data="data.yaml", epochs=100)    # the YOLO-format labels you already have
+model.val(data="data.yaml")                  # mAP50 / mAP50-95
+model.export(half=True)                      # -> IR + labels.txt
+
+r = model("bus.jpg", conf=0.5)               # ovkit Results: print(r), r.found, r.save()
+```
+
+The exported IR drops straight into `Model("path/to/rtdetr-r18.xml")` — the
+`labels.txt` written next to it means your classes answer by name. CLI:
+`ovkit train --data data.yaml`, `ovkit val`, `ovkit export`.
+`ovkit capabilities` prints the list; **`ovkit gui` opens a window** where you can
+click through them against your webcam or a picture.
+
 ## Supported tasks
 
-Every task below runs end-to-end through the same 3 lines — swap the alias:
+Every single-model task below runs end-to-end through the same 3 lines — swap the alias:
 
 | Task | Alias | Output | Example |
 | ---- | ----- | ------ | ------- |
@@ -61,6 +163,7 @@ Every task below runs end-to-end through the same 3 lines — swap the alias:
 | Pose / landmarks | `pose`, `face_landmarks` | `r.keypoints` | [pose.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/pose.py) |
 | Face analysis | `age_gender`, `emotion`, `head_pose`, `face_reid` | `r.text` (e.g. `"age 31 · male 98%"`) | [face_analysis.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/face_analysis.py) |
 | OCR | `text_recognition` | `r.text` | [ocr.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/ocr.py) |
+| Tracking / matching | `track`, `face_match` | `r.track_ids` · `(label, score)` | [track.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/track.py) / [face_match.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/face_match.py) |
 | Super-resolution | `super_resolution` | upscaled image via `r.plot()` | [super_resolution.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/super_resolution.py) |
 | LLM / STT (GenAI) | `llm`, `stt` | generated text | [llm.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/llm.py) / [stt.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/stt.py) |
 | NLP / audio / time series | `qa`, `translation`, `noise_suppression`, `time_series` | tensors via `model.infer()` | [denoise_audio.py](https://github.com/leeyunjai82/ovkit/blob/main/examples/denoise_audio.py) |
@@ -129,7 +232,10 @@ control for any model: `model.infer({name: tensor})` with `model.inputs`.
 | `r.boxes` | `xyxy`, `xywh`, `conf`, `cls` |
 | `r.masks` / `r.keypoints` / `r.probs` | masks · `[x,y,conf]` · `top1`/`top5` |
 | `r.text` | decoded text (OCR, face attributes) |
+| `r.labels` / `r.track_ids` | per-box label a pipeline wrote · per-box track id |
 | `r.tensors` | raw `{name: ndarray}` |
+| `r.summary()` | the whole result as one readable line |
+| `r.crop(i)` / `r.to_dict()` / `r.to_json()` | cut a box out · plain Python · JSON |
 | `r.plot()` / `r.save(path)` | annotated image (or the model's output image) |
 
 </details>

{ovkit-0.1.2 → ovkit-0.3.0}/examples/README.md

@@ -16,6 +16,7 @@ pip install -r examples/requirements.txt # fastapi / uvicorn (web demos only)
 | [`classify.py`](classify.py) | `classify` | top-5 classes |
 | [`ocr.py`](ocr.py) | `text_recognition` | decoded text |
 | [`super_resolution.py`](super_resolution.py) | `super_resolution` | upscaled image |
+| [`background_matting.py`](background_matting.py) | `background_matting_mobilenetv2` | cut the subject out (needs frame + empty-scene photo) |
 
 ```bash
 python examples/detect.py photo.jpg      # each is ~15 lines — read the source

{ovkit-0.1.2 → ovkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ovkit"
-version = "0.1.2"
+version = "0.3.0"
 description = "A simple Python inference API for OpenVINO: one import, one Model class, clean Results — with AUTO/NPU, async, and INT8."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,7 +33,9 @@ dependencies = [
 genai = ["openvino-genai", "optimum-intel"]
 anomaly = ["anomalib"]
 quant = ["nncf"]
-all = ["openvino-genai", "optimum-intel", "anomalib", "nncf"]
+train = ["torch>=2.0", "torchvision>=0.15", "scipy", "onnx"]
+hand = ["mediapipe"]
+all = ["openvino-genai", "optimum-intel", "anomalib", "nncf", "torch>=2.0", "torchvision>=0.15", "scipy", "onnx"]
 dev = ["pytest>=7", "ruff", "black"]
 
 [project.urls]

{ovkit-0.1.2 → ovkit-0.3.0}/src/ovkit/__init__.py

@@ -3,14 +3,23 @@
 One import, one :class:`Model` class, a callable object, and clean
 :class:`Results` — plus OpenVINO's strengths (AUTO/NPU devices, async, INT8).
 
-Example
--------
+One model
+---------
 >>> from ovkit import Model
 >>> model = Model("rtdetr_r50")          # name -> auto download/convert/cache
 >>> results = model("img.jpg", conf=0.25)
 >>> for r in results:
-...     print(r.boxes.xyxy, r.boxes.conf, r.boxes.cls)
+...     print(r.summary())               # '2x person, car'
 ...     r.save("out.jpg")
+
+Several models, one answer
+--------------------------
+>>> from ovkit import Model
+>>> for r in Model("face_analyze")("group.jpg"):
+...     print(r.summary())               # '2 faces: age 31 · male 98% · happy 92%, ...'
+
+A capability name composes the models the answer needs — detection plus
+whatever describes what was found. :func:`list_pipelines` shows them all.
 """
 
 from __future__ import annotations
@@ -29,11 +38,24 @@ from .core.errors import (
 from .core.model import Model
 from .core.registry import list_models
 from .core.results import Boxes, Keypoints, Masks, Probs, Results
+from .pipelines import Pipeline, list_pipelines
+
+__version__ = "0.3.0"
+
+
+def __getattr__(name: str):  # lazy: keeps `import ovkit` free of the train stack
+    if name == "RTDETR":
+        from .rtdetr import RTDETR
+
+        return RTDETR
+    raise AttributeError(f"module 'ovkit' has no attribute {name!r}")
 
-__version__ = "0.1.2"
 
 __all__ = [
     "Model",
+    "RTDETR",
+    "Pipeline",
+    "list_pipelines",
     "Results",
     "Boxes",
     "Masks",

{ovkit-0.1.2 → ovkit-0.3.0}/src/ovkit/__main__.py

@@ -1,4 +1,4 @@
-"""``ovkit`` command-line interface: ``run``, ``list``, ``info``, ``download``, ``devices``."""
+"""``ovkit`` CLI: ``gui``, ``run``, ``train``, ``val``, ``export``, ``list``, ``info``, ``download``, ``devices``."""
 
 from __future__ import annotations
 
@@ -41,6 +41,19 @@ def _cmd_list(_: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_capabilities(_: argparse.Namespace) -> int:
+    """What ``Model(name)`` can answer beyond a single network."""
+    from .pipelines import ALIASES, list_pipelines
+
+    print("capabilities — Model(name) chains the models the answer needs:\n")
+    for name, description in list_pipelines().items():
+        print(f"  {name:16s} {description}")
+    print("\naliases:")
+    for alias, target in sorted(ALIASES.items()):
+        print(f"  {alias:16s} -> {target}")
+    return 0
+
+
 def _cmd_info(args: argparse.Namespace) -> int:
     entry = resolve(args.name)
     if entry is None:
@@ -96,25 +109,12 @@ def _cmd_run(args: argparse.Namespace) -> int:
         return 0
 
     for r in results:
-        parts = [f"task={r.task}"]
-        if r.text:
-            parts.append(f'text="{r.text}"')
+        print(r.summary())
         if r.boxes is not None:
-            parts.append(f"{len(r.boxes)} boxes")
             for x1, y1, x2, y2, c, cl in r.boxes.data[:20]:
                 print(
                     f"  {r.name_for(int(cl)):16s} {c:.2f} [{int(x1)},{int(y1)},{int(x2)},{int(y2)}]"
                 )
-        if r.probs is not None:
-            top = ", ".join(
-                f"{r.name_for(int(i))} {r.probs.data[int(i)]:.2f}" for i in r.probs.top5
-            )
-            parts.append(f"top-5: {top}")
-        if r.masks is not None:
-            parts.append(f"masks {tuple(r.masks.data.shape)}")
-        if r.keypoints is not None:
-            parts.append(f"keypoints {tuple(r.keypoints.data.shape)}")
-        print(" | ".join(parts))
 
     save = args.save
     if save is None and results and Path(str(args.source)).is_file():
@@ -125,15 +125,57 @@ def _cmd_run(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_gui(args: argparse.Namespace) -> int:
+    """Open the desktop window: ``ovkit gui``."""
+    from .gui import main as gui_main
+
+    return gui_main(device=args.device, camera=args.camera)
+
+
+def _cmd_train(args: argparse.Namespace) -> int:
+    """Train RT-DETR on YOLO-format data: ``ovkit train --data data.yaml``."""
+    from .rtdetr import RTDETR
+
+    model = RTDETR(args.model, device=args.device)
+    best = model.train(
+        data=args.data, epochs=args.epochs, imgsz=args.imgsz, batch=args.batch, lr=args.lr
+    )
+    print(f"best checkpoint: {best}")
+    return 0
+
+
+def _cmd_val(args: argparse.Namespace) -> int:
+    from .rtdetr import RTDETR
+
+    RTDETR(args.model, device=args.device).val(data=args.data, imgsz=args.imgsz)
+    return 0
+
+
+def _cmd_export(args: argparse.Namespace) -> int:
+    from .rtdetr import RTDETR
+
+    out = RTDETR(args.model).export(imgsz=args.imgsz, half=args.half, out_dir=args.out)
+    print(f"exported: {out} (+ labels.txt)")
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     """CLI entry point. Returns a process exit code."""
     parser = argparse.ArgumentParser(prog="ovkit", description="ovkit model utilities")
     parser.add_argument("--version", action="version", version=f"ovkit {__version__}")
     sub = parser.add_subparsers(dest="command", required=True)
 
+    p_gui = sub.add_parser("gui", help="open the desktop window (easiest way to try ovkit)")
+    p_gui.add_argument("--device", default="AUTO", help="AUTO | CPU | GPU | NPU")
+    p_gui.add_argument("--camera", type=int, default=0, help="camera index for the webcam button")
+    p_gui.set_defaults(func=_cmd_gui)
+
     p_list = sub.add_parser("list", help="list registered models")
     p_list.set_defaults(func=_cmd_list)
 
+    p_caps = sub.add_parser("capabilities", help="list composed capabilities (Model(name))")
+    p_caps.set_defaults(func=_cmd_capabilities)
+
     p_info = sub.add_parser("info", help="show details for a model")
     p_info.add_argument("name")
     p_info.set_defaults(func=_cmd_info)
@@ -143,6 +185,30 @@ def main(argv: list[str] | None = None) -> int:
     p_dl.add_argument("--no-convert", action="store_true", help="skip IR conversion")
     p_dl.set_defaults(func=_cmd_download)
 
+    p_train = sub.add_parser("train", help="train RT-DETR on your own data (needs ovkit[train])")
+    p_train.add_argument("--data", required=True, help="data.yaml (YOLO format)")
+    p_train.add_argument("--model", default="rtdetr-r18", help="variant or a .pt to resume")
+    p_train.add_argument("--epochs", type=int, default=100)
+    p_train.add_argument("--imgsz", type=int, default=640)
+    p_train.add_argument("--batch", type=int, default=8)
+    p_train.add_argument("--lr", type=float, default=1e-4)
+    p_train.add_argument("--device", default=None)
+    p_train.set_defaults(func=_cmd_train)
+
+    p_val = sub.add_parser("val", help="mAP on the val split of a data.yaml")
+    p_val.add_argument("--model", required=True, help="a trained .pt")
+    p_val.add_argument("--data", required=True)
+    p_val.add_argument("--imgsz", type=int, default=640)
+    p_val.add_argument("--device", default=None)
+    p_val.set_defaults(func=_cmd_val)
+
+    p_exp = sub.add_parser("export", help="export a trained .pt to OpenVINO IR + labels.txt")
+    p_exp.add_argument("--model", required=True, help="a trained .pt")
+    p_exp.add_argument("--imgsz", type=int, default=640)
+    p_exp.add_argument("--half", action="store_true", help="FP16 IR")
+    p_exp.add_argument("--out", default=".", help="output directory")
+    p_exp.set_defaults(func=_cmd_export)
+
     p_dev = sub.add_parser("devices", help="list OpenVINO devices")
     p_dev.set_defaults(func=_cmd_devices)
 

ovkit-0.3.0/src/ovkit/audio/__init__.py

@@ -0,0 +1,13 @@
+"""Audio I/O helpers: read a file into the array a model actually wants.
+
+Models want float32 mono at a fixed sample rate; files are int16 stereo at
+whatever rate the recorder used. These helpers close that gap so callers never
+have to touch :mod:`wave` or write their own resampler.
+"""
+
+from __future__ import annotations
+
+from .ops import read_audio, read_wav, resample, to_mono, write_wav
+from .plot import waveform
+
+__all__ = ["read_audio", "read_wav", "resample", "to_mono", "waveform", "write_wav"]