easydetect 0.2.3__tar.gz → 0.3.1__tar.gz

{easydetect-0.2.3 → easydetect-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: easydetect
-Version: 0.2.3
+Version: 0.3.1
 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
@@ -34,6 +34,7 @@ Requires-Dist: pillow>=9.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.5; extra == 'dev'
 Provides-Extra: train
+Requires-Dist: nncf>=2.10; extra == 'train'
 Requires-Dist: onnx>=1.14; extra == 'train'
 Requires-Dist: scipy>=1.9; extra == 'train'
 Requires-Dist: torch>=2.1; extra == 'train'

{easydetect-0.2.3 → easydetect-0.3.1}/easydetect/__init__.py

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

{easydetect-0.2.3 → easydetect-0.3.1}/easydetect/cli.py

@@ -28,7 +28,7 @@ Modes:
 
 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  iou=0.7|none  device=0|cpu|AUTO
+  data=data.yaml  epochs=100  imgsz=640  batch=8  conf=0.5  iou=0.7|none  device=0|cpu|AUTO
   contain=0.8  project=runs  name=predict  save=true  show=false  format=openvino  half=true
 
 Examples:

{easydetect-0.2.3 → easydetect-0.3.1}/easydetect/exporter.py

@@ -31,8 +31,12 @@ def _write_labels(out_dir: Path, fname: str, names) -> dict[int, str]:
     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."""
+def export_onnx(net, names, imgsz=640, out_dir=".", fname="easydetect", half=False, verbose=True,
+                layers=None, queries=None):
+    """Write ``<out_dir>/<fname>.onnx`` (plus labels). Returns the .onnx path.
+
+    ``layers`` / ``queries`` export a lighter decoder: see ``DFINENet.trim``.
+    """
     import torch
 
     from .nn import DeployWrapper
@@ -44,6 +48,8 @@ def export_onnx(net, names, imgsz=640, out_dir=".", fname="easydetect", half=Fal
     # 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()
+    if layers is not None or queries is not None:
+        deployed.trim(layers=layers, queries=queries)
     deployed = deployed.deploy() if hasattr(deployed, "deploy") else deployed.eval()
     wrapper = DeployWrapper(deployed).eval()
     dummy = torch.zeros(1, 3, imgsz, imgsz)
@@ -87,18 +93,49 @@ def _embed_names(onnx_path: Path, table: dict[int, str]) -> None:
 
 
 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."""
+                    verbose=True, layers=None, queries=None, int8=None):
+    """Write ``<out_dir>/<fname>.xml`` (+ .bin, + labels). Returns the .xml path.
+
+    ``int8`` is a list of image paths to calibrate an 8-bit model on (NNCF's
+    post-training quantization; a few hundred pictures like the ones it will
+    see). It runs about as fast as bfloat16 where the CPU has that, and over
+    twice as fast as float32 where it does not — most laptop CPUs.
+    """
     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
+        net, names, imgsz=imgsz, out_dir=out_dir, fname=fname, verbose=False,
+        layers=layers, queries=queries,
     )
     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 int8:
+        model = _quantize(model, int8, imgsz)
+    ov.save_model(model, str(xml_path), compress_to_fp16=half and not int8)
     if verbose:
-        print(f"[easydetect] exported: {xml_path} ({'FP16' if half else 'FP32'})")
+        kind = "INT8" if int8 else "FP16" if half else "FP32"
+        print(f"[easydetect] exported: {xml_path} ({kind})")
     return xml_path
+
+
+def _quantize(model, images, imgsz):
+    """8-bit weights and activations, calibrated on ``images`` (paths)."""
+    import cv2
+    import nncf
+
+    from .predictor import preprocess_image
+
+    images = [str(p) for p in images]
+    if not images:
+        raise ValueError("int8 needs pictures to calibrate on: give data=")
+
+    def transform(path):
+        img = cv2.imread(path)
+        if img is None:
+            raise ValueError(f"cannot read {path}")
+        return preprocess_image(img, imgsz)
+
+    return nncf.quantize(model, nncf.Dataset(images, transform), subset_size=len(images),
+                         model_type=nncf.ModelType.TRANSFORMER)

{easydetect-0.2.3 → easydetect-0.3.1}/easydetect/model.py

@@ -114,7 +114,7 @@ class Detector:
     def predict(
         self,
         source: Any = None,
-        conf: float = 0.25,
+        conf: float = 0.5,
         imgsz: int | None = None,
         device: str | None = None,
         max_det: int = 300,
@@ -134,12 +134,14 @@ class Detector:
         """Run detection on any supported source.
 
         Returns a ``list[Results]``, or a generator when ``stream=True`` (the
-        only sane option for a long video or a live camera). ``iou`` drops a
-        box covering a higher-scoring one by more than that IoU — the same
-        object found twice, sometimes under two classes; ``None`` keeps all.
-        ``contain=0.8`` also merges a box with 80% of its area inside another
-        of its class — the visible pieces of a half hidden object reported
-        beside the whole of it — into one box. Off by default.
+        only sane option for a long video or a live camera). ``conf=0.5``
+        is where D-FINE's boxes are mostly right (70% on COCO, against 32% at
+        YOLO's usual 0.25). ``iou`` drops a box covering a higher-scoring one
+        by more than that IoU — the same object found twice, sometimes under
+        two classes; ``None`` keeps all. ``contain=0.8`` also merges a box
+        with 80% of its area inside another of its class — the visible pieces
+        of a half hidden object beside the whole of it — into one box; off by
+        default, as on COCO it removes more real objects than it fixes.
         """
         if source is None:
             raise ValueError("predict() needs a source (image, folder, video, url, camera index)")
@@ -171,7 +173,7 @@ class Detector:
     def track(
         self,
         source: Any = None,
-        conf: float = 0.25,
+        conf: float = 0.5,
         iou: float | None = 0.7,
         contain: float | None = None,
         match_iou: float = 0.3,
@@ -209,7 +211,7 @@ class Detector:
     def _run(
         self,
         source: Any,
-        conf: float = 0.25,
+        conf: float = 0.5,
         imgsz: int | None = None,
         device: str | None = None,
         max_det: int = 300,
@@ -500,8 +502,22 @@ class Detector:
         half: bool = False,
         out_dir: str | Path | None = None,
         verbose: bool | None = None,
+        layers: int | None = None,
+        queries: int | None = None,
+        int8: bool = False,
+        data: Any = None,
+        calib: int = 300,
     ) -> Path:
-        """Export to OpenVINO IR (default) or ONNX. Returns the file written."""
+        """Export to OpenVINO IR (default) or ONNX. Returns the file written.
+
+        ``int8=True`` (OpenVINO only) quantizes the IR to 8 bits, calibrated
+        on ``calib`` pictures from ``data`` — a data.yaml (its train split), a
+        folder or a list of files — and writes ``<name>_int8.xml``.
+
+        ``layers`` (decoder layers to run, of 3-6 by size) and ``queries`` (of
+        300) export a faster, slightly less accurate model; dfine-n at 320 on
+        a 4-core CPU: 19.9 ms, 13.2 ms with ``queries=100``.
+        """
         format = format.lower()
         if format not in ("openvino", "onnx"):
             raise ValueError("supported formats: 'openvino', 'onnx'")
@@ -513,10 +529,18 @@ class Detector:
         imgsz = imgsz or (self.ckpt or {}).get("imgsz", 640)
         stem = self.ckpt_path.stem if self.ckpt_path else f"easydetect-{self.variant}"
         verbose = self.verbose if verbose is None else verbose
+        if int8:
+            if format != "openvino":
+                raise ValueError("int8 is an OpenVINO export: format='openvino'")
+            return export_openvino(
+                self.net, self.names, imgsz=imgsz, out_dir=out_dir, fname=f"{stem}_int8",
+                verbose=verbose, layers=layers, queries=queries,
+                int8=_calibration_images(data, calib),
+            )
         exporter = export_openvino if format == "openvino" else export_onnx
         return exporter(
             self.net, self.names, imgsz=imgsz, out_dir=out_dir, fname=stem,
-            half=half, verbose=verbose,
+            half=half, verbose=verbose, layers=layers, queries=queries,
         )
 
     # -------------------------------------------------------------------- misc
@@ -531,6 +555,29 @@ class Detector:
         return f"Detector({self.model_name!r}, device={self.device!r})"
 
 
+def _calibration_images(data: Any, count: int) -> list[Path]:
+    """Up to ``count`` pictures spread over a data.yaml's train split, a folder or a list."""
+    from .data.dataset import list_images, load_data_yaml
+
+    if data is None:
+        raise ValueError("int8=True needs pictures to calibrate on: data='data.yaml' or a folder")
+    if isinstance(data, (list, tuple)):
+        files = [Path(f) for f in data]
+    else:
+        path = Path(data).expanduser()
+        if path.suffix in (".yaml", ".yml"):
+            cfg = load_data_yaml(path)
+            files = list_images(cfg["root"], cfg["train"], cfg["yaml_dir"])
+        elif path.is_dir():
+            files = list_images(path, ".")
+        else:
+            raise ValueError(f"{data}: give a data.yaml, a folder of pictures or a list")
+    if not files:
+        raise ValueError(f"no pictures found in {data}")
+    step = max(len(files) // max(int(count), 1), 1)
+    return files[::step][:count]
+
+
 class _Stream:
     """The generator ``stream=True`` hands back, plus a nudge when it is dropped.
 

{easydetect-0.2.3 → easydetect-0.3.1}/easydetect/nn/dfine_net.py

@@ -85,6 +85,30 @@ class DFINENet(nn.Module):
     def forward(self, x, targets=None):
         return self.decoder(self.encoder(self.backbone(x)), targets)
 
+    def trim(self, layers: int | None = None, queries: int | None = None) -> DFINENet:
+        """Run fewer decoder layers or queries (in place, before :meth:`deploy`).
+
+        Every decoder layer is trained to answer on its own (each has its own
+        score and box heads and its own loss), so stopping after ``layers`` of
+        them gives a working detector that skips the rest. ``queries`` is how
+        many candidate boxes the encoder hands the decoder (300 as trained);
+        a scene with a handful of objects needs far fewer. Both cost accuracy
+        and buy speed — measure on your data (docs/performance.md).
+        """
+        dec = self.decoder
+        if hasattr(dec.decoder, "project"):          # convert_to_deploy() has run
+            raise RuntimeError("trim() before deploy(): a deployed network has dropped its layers")
+        if layers is not None:
+            if not 1 <= int(layers) <= dec.num_layers:
+                raise ValueError(
+                    f"layers must be 1..{dec.num_layers} for D-FINE-{self.variant.upper()}")
+            dec.eval_idx = dec.decoder.eval_idx = int(layers) - 1
+        if queries is not None:
+            if not 1 <= int(queries) <= dec.num_queries:
+                raise ValueError(f"queries must be 1..{dec.num_queries}")
+            dec.num_queries = int(queries)
+        return self
+
     def deploy(self) -> DFINENet:
         """Fuse re-parameterisable blocks and drop training-only heads (in place)."""
         self.eval()

{easydetect-0.2.3 → easydetect-0.3.1}/easydetect/predictor.py

@@ -128,6 +128,12 @@ def read_names(model_path: Path) -> dict[int, str]:
 #: Default for ``iou``: above this IoU, two boxes are one object.
 IOU = 0.7
 
+#: Default for ``conf``. D-FINE gives an unsure box 0.3-0.5 where YOLO would
+#: give it under 0.25, so YOLO's 0.25 shows mostly mistakes here: dfine-m on
+#: COCO val2017 (NMS 0.7) shows boxes 32% right at 0.25, 70% at 0.5, while
+#: still finding 67% of the objects. See docs/performance.md.
+CONF = 0.5
+
 
 def drop_duplicates(xyxy: np.ndarray, iou: float = IOU) -> np.ndarray:
     """Indices of the boxes to keep, from boxes sorted best first.
@@ -277,7 +283,7 @@ class Predictor:
         boxes: np.ndarray,
         scores: np.ndarray,
         orig_shape: tuple[int, int],
-        conf: float = 0.25,
+        conf: float = CONF,
         max_det: int = 300,
         classes: list[int] | None = None,
         iou: float | None = IOU,
@@ -322,7 +328,7 @@ class Predictor:
     def __call__(
         self,
         img: np.ndarray,
-        conf: float = 0.25,
+        conf: float = CONF,
         max_det: int = 300,
         classes: list[int] | None = None,
         iou: float | None = IOU,

{easydetect-0.2.3 → easydetect-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "easydetect"
-version = "0.2.3"
+version = "0.3.1"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -45,6 +45,7 @@ train = [
     "torchvision>=0.16",
     "scipy>=1.9",
     "onnx>=1.14",
+    "nncf>=2.10",   # INT8 export
 ]
 dev = [
     "pytest>=7.0",

{easydetect-0.2.3 → easydetect-0.3.1}/tests/test_predictor.py

@@ -201,3 +201,15 @@ def test_the_whole_path_merges_pieces_only_when_asked():
     assert sorted(merged[:, 5].tolist()) == [0, 56]         # one person, one chair
     chair = merged[merged[:, 5] == 56][0]
     assert chair[:4].round().tolist() == [285, 455, 373, 640]   # the whole of it
+
+
+def test_the_defaults_are_the_measured_ones():
+    """conf 0.5, NMS 0.7, contain off: docs/performance.md, 'Confidence and overlap defaults'."""
+    import inspect
+
+    from easydetect import Detector
+
+    for method in (Detector.predict, Detector.track):
+        params = inspect.signature(method).parameters
+        assert params["conf"].default == 0.5 and params["iou"].default == 0.7
+        assert params["contain"].default is None

{easydetect-0.2.3 → easydetect-0.3.1}/tests/test_train_export.py

@@ -333,3 +333,50 @@ def test_a_learning_rate_that_is_given_is_used_as_it_is(dataset, tmp_path, monke
     assert opt["lr"] == pytest.approx(3e-4) and opt["lr_from"] == "set"
     assert opt["lr_backbone"] == pytest.approx(0.75e-4)
     assert opt["warmup_epochs"] == 0 and opt["weight_decay"] == 0.0
+
+
+def test_a_lighter_decoder_exports_and_predicts(tmp_path, image):
+    """layers / queries: fewer decoder layers and candidate boxes, same outputs otherwise."""
+    import onnxruntime as ort
+
+    from easydetect.exporter import export_onnx
+    from easydetect.nn import DFINENet
+
+    net = DFINENet("n", 2, pretrained_backbone=False)
+    names = {0: "a", 1: "b"}
+    full = export_onnx(net, names, imgsz=256, out_dir=tmp_path, fname="full", verbose=False)
+    light = export_onnx(net, names, imgsz=256, out_dir=tmp_path, fname="light", verbose=False,
+                        layers=1, queries=50)
+    shapes = {}            # at 256 px dfine-n has 16x16 + 8x8 places to start a box: over 300
+    for path in (full, light):
+        session = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"])
+        outs = session.run(None, {"images": np.zeros((1, 3, 256, 256), np.float32)})
+        shapes[path.stem] = [o.shape for o in outs]
+    assert shapes["full"] == [(1, 300, 4), (1, 300, 2)]
+    assert shapes["light"] == [(1, 50, 4), (1, 50, 2)]
+    assert net.decoder.num_queries == 300            # the caller's network is untouched
+
+    with pytest.raises(ValueError, match="layers must be 1..3"):
+        DFINENet("n", 2, pretrained_backbone=False).trim(layers=4)
+    with pytest.raises(RuntimeError, match="before deploy"):
+        DFINENet("n", 2, pretrained_backbone=False).deploy().trim(queries=10)
+
+
+@needs_ov
+def test_an_int8_export_calibrates_on_the_dataset_and_predicts(trained, dataset, tmp_path, image):
+    pytest.importorskip("nncf")
+    model, _ = trained
+    xml = model.export(format="openvino", imgsz=64, out_dir=tmp_path, int8=True,
+                       data=str(dataset), calib=4, verbose=False)
+    assert xml.name.endswith("_int8.xml") and xml.with_suffix(".bin").exists()
+    import openvino as ov
+
+    ops = {op.get_type_name() for op in ov.Core().read_model(str(xml)).get_ops()}
+    assert "FakeQuantize" in ops                        # 8-bit, not a float IR renamed
+    results = Detector(str(xml), device="CPU", verbose=False)(image, conf=0.0, max_det=2)
+    assert results[0].names == {0: "box"} and results[0].boxes.xyxy.shape == (2, 4)
+
+    with pytest.raises(ValueError, match="calibrate"):
+        model.export(format="openvino", imgsz=64, out_dir=tmp_path, int8=True)
+    with pytest.raises(ValueError, match="OpenVINO export"):
+        model.export(format="onnx", imgsz=64, out_dir=tmp_path, int8=True, data=str(dataset))

easydetect-0.3.1/tools/eval_exports.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# Apache-2.0
+"""Lighter exports side by side: fewer queries or decoder layers, INT8.
+
+    python tools/eval_exports.py --data ~/datasets/coco/data.yaml --model dfine-n --imgsz 320
+    python tools/eval_exports.py --data data.yaml --model runs/train/weights/best.pt
+
+Each config (``layers:queries[:int8]``, ``all`` for every layer) is exported
+from the same checkpoint (a mirror name's COCO .pt, or yours) and scored on
+the same val pictures: mAP50-95 / mAP50 with every box (as ``val`` does),
+precision and recall of what ``predict`` shows by default (conf 0.5, NMS 0.7),
+and the median inference time. INT8 calibrates on the first ``--calib`` val
+pictures, which are then left out of the scoring for every config alike.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+from easydetect import Detector, downloads
+from easydetect.data.dataset import DetDataset
+from easydetect.predictor import drop_duplicates
+from easydetect.validator import Evaluator
+
+DEFAULT_CONFIGS = ["all:300", "all:100", "2:300", "1:300", "1:100", "all:300:int8", "all:100:int8"]
+
+
+def box_iou(x, y):
+    tl = np.maximum(x[:, None, :2], y[None, :, :2])
+    br = np.minimum(x[:, None, 2:], y[None, :, 2:])
+    inter = np.prod(np.clip(br - tl, 0, None), axis=2)
+    ax = np.prod(x[:, 2:] - x[:, :2], axis=1)
+    ay = np.prod(y[:, 2:] - y[:, :2], axis=1)
+    return inter / np.maximum(ax[:, None] + ay[None, :] - inter, 1e-9)
+
+
+def shown_and_correct(r, gt, gk, w, h):
+    """Boxes predict() shows by default (conf 0.5, NMS 0.7) and how many match a truth box."""
+    keep = r.boxes.conf >= 0.5
+    xyxy, cls = r.boxes.xyxy[keep].astype(np.float32), r.boxes.cls[keep].astype(int)
+    if len(xyxy) > 1:
+        kept = drop_duplicates(xyxy, 0.7)
+        xyxy, cls = xyxy[kept], cls[kept]
+    if not len(xyxy) or not len(gt):
+        return len(xyxy), 0
+    ious = box_iou(xyxy / [w, h, w, h], gt)
+    taken = np.zeros(len(gt), bool)
+    correct = 0
+    for i in range(len(xyxy)):
+        cand = np.where((gk == cls[i]) & ~taken & (ious[i] >= 0.5))[0]
+        if len(cand):
+            taken[cand[ious[i, cand].argmax()]] = True
+            correct += 1
+    return len(xyxy), correct
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--data", required=True)
+    parser.add_argument("--model", default="dfine-n", help="a mirror name (its COCO .pt) or a .pt")
+    parser.add_argument("--imgsz", type=int, default=640)
+    parser.add_argument("--configs", nargs="+", default=DEFAULT_CONFIGS,
+                        help="layers:queries[:int8]; 'all' = every decoder layer")
+    parser.add_argument("--calib", type=int, default=300, help="pictures to calibrate INT8 on")
+    parser.add_argument("--device", default="CPU")
+    parser.add_argument("--limit", type=int, help="score only the first N pictures")
+    parser.add_argument("--out", default="exports", help="where the exported variants go")
+    args = parser.parse_args()
+
+    pt = Path(args.model)
+    if pt.suffix != ".pt":
+        pt = downloads.download_checkpoint(args.model)
+    ds = DetDataset(Path(args.data).expanduser(), "val", 64, augment=False)
+    calib, files = ds.files[:args.calib], ds.files[args.calib:]
+    files = files[:args.limit] if args.limit else files
+    truth = []
+    for f in files:
+        lab = ds._load_labels(f)
+        cx, cy, bw, bh = lab[:, 1], lab[:, 2], lab[:, 3], lab[:, 4]
+        truth.append((np.stack([cx - bw / 2, cy - bh / 2, cx + bw / 2, cy + bh / 2], 1),
+                      lab[:, 0].astype(int)))
+    n_truth = sum(len(t[1]) for t in truth)
+
+    rows = []
+    for config in args.configs:
+        layers, queries, *rest = config.split(":")
+        int8 = rest == ["int8"]
+        out = Path(args.out) / f"{pt.stem}-{args.imgsz}-{config.replace(':', '-')}"
+        xml = Detector(str(pt), verbose=False).export(
+            format="openvino", imgsz=args.imgsz, out_dir=out,
+            layers=None if layers == "all" else int(layers), queries=int(queries),
+            int8=int8, data=calib if int8 else None, calib=args.calib, verbose=False)
+        model = Detector(str(xml), device=args.device, verbose=False)
+        for _ in range(3):                   # compile and warm up before the clock runs
+            model(cv2.imread(str(files[0])), verbose=False)
+        ev, shown, correct, times = Evaluator(ds.nc), 0, 0, []
+        for k, (f, (gt, gk)) in enumerate(zip(files, truth, strict=True)):
+            img = cv2.imread(str(f))
+            h, w = img.shape[:2]
+            r = model(img, conf=0.001, iou=None, max_det=300, verbose=False)[0]
+            times.append(r.speed["inference"])
+            ev.add(r.boxes.xyxy / [w, h, w, h], r.boxes.conf, r.boxes.cls.astype(int), gt, gk)
+            s, c = shown_and_correct(r, gt, gk, w, h)
+            shown, correct = shown + s, correct + c
+            if (k + 1) % 1000 == 0:
+                print(f"  {config}: {k + 1}/{len(files)}", flush=True)
+        m = ev.compute()
+        rows.append((config, m["map"], m["map50"], correct / max(shown, 1),
+                     correct / max(n_truth, 1), float(np.median(times))))
+        print(f"  {config}: mAP50-95 {m['map']:.4f}, {rows[-1][-1]:.1f} ms", flush=True)
+
+    print(f"\n{pt.stem} at {args.imgsz}, {len(files)} pictures, {args.device}")
+    print(f"{'config':<16}{'mAP50-95':>9}{'mAP50':>8}{'P@0.5':>8}{'R@0.5':>8}{'ms':>8}")
+    for config, m, m50, precision, recall, ms in rows:
+        print(f"{config:<16}{m:9.4f}{m50:8.4f}{precision:8.1%}{recall:8.1%}{ms:8.1f}")
+
+
+if __name__ == "__main__":
+    main()

{easydetect-0.2.3 → easydetect-0.3.1}/tools/hub_README.md

@@ -29,7 +29,7 @@ pip install easydetect          # OpenVINO and ONNX Runtime, no PyTorch
 from easydetect import Detector
 
 model = Detector("dfine-s")                 # downloads dfine-s/ from this repo once
-results = model("photo.jpg", conf=0.25)
+results = model("photo.jpg", conf=0.5)
 results[0].save("result.jpg")
 
 for r in model.predict(0, stream=True, show=True):   # webcam; q or Esc quits