easydetect 0.7.2__tar.gz → 0.7.3__tar.gz

{easydetect-0.7.2 → easydetect-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: easydetect
-Version: 0.7.2
+Version: 0.7.3
 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

{easydetect-0.7.2 → easydetect-0.7.3}/easydetect/__init__.py

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

{easydetect-0.7.2 → easydetect-0.7.3}/easydetect/model.py

@@ -457,6 +457,11 @@ class Detector:
         self.names = {int(k): str(v) for k, v in ckpt.get("names", {}).items()}
         self.net = DFINENet(ckpt["variant"], ckpt["num_classes"], pretrained_backbone=False)
         self.net.load_state_dict(ckpt["model"])
+        # trained with fewer queries: runs (and fine-tunes again) with as many
+        if ckpt.get("queries") and ckpt["queries"] != self.net.decoder.num_queries:
+            self.net.trim(queries=int(ckpt["queries"]))
+        if ckpt.get("denoising") is not None:
+            self.net.decoder.num_denoising = int(ckpt["denoising"])
         self.net.eval()
         self.ir_path = None
         self.predictor = None
@@ -505,6 +510,8 @@ class Detector:
         seg_epochs: int = 20,
         seg_batch: int = 16,
         seg_lr: float = 1e-4,
+        queries: int | None = None,
+        denoising: int | None = None,
         **kwargs: Any,
     ) -> Path:
         """Train on a data.yaml dataset. Returns the path of ``best.pt``.
@@ -518,6 +525,12 @@ class Detector:
         ``on_epoch_end`` is called with a dict of the epoch's numbers — the
         same row that lands in ``results.csv``.
 
+        ``queries`` (of 300) and ``denoising`` (training-only queries, 100)
+        make every step cheaper; on a CPU most of a step is spent on them, not
+        on the picture. ``queries=100, denoising=30`` trains dfine-n about
+        twice as fast on a laptop and suits scenes with a handful of objects;
+        the model keeps ``queries`` (it runs faster too).
+
         A keypoint dataset (``kpt_shape`` in its data.yaml, Ultralytics' pose
         format) also trains a keypoint network after the detector: on crops of
         the labelled boxes, from the detector's backbone, for ``pose_epochs``
@@ -561,6 +574,10 @@ class Detector:
         elif self.net.num_classes != cfg["nc"]:
             self.net = self._reheaded_net(cfg["nc"])
 
+        if queries is not None:
+            self.net.trim(queries=int(queries))
+        if denoising is not None:
+            self.net.decoder.num_denoising = int(denoising)
         device = _torch_device(device)
         trainer = Trainer(
             self.net,

{easydetect-0.7.2 → easydetect-0.7.3}/easydetect/trainer.py

@@ -436,6 +436,8 @@ class Trainer:
             # a resumed run started where its first attempt did
             "start": old.get("start") or self.origin,
             "imgsz": self.imgsz,
+            "queries": self.net.decoder.num_queries,
+            "denoising": self.net.decoder.num_denoising,
             "batch": self.batch,
             "epochs": self.epochs,
             "patience": self.patience,
@@ -736,6 +738,8 @@ class Trainer:
                 "scaler": self.scaler.state_dict() if self.amp else None,
                 "variant": net.variant,
                 "num_classes": net.num_classes,
+                "queries": net.decoder.num_queries,
+                "denoising": net.decoder.num_denoising,
                 "names": self.cfg["names"],
                 "epoch": epoch,
                 "best": self.best,

{easydetect-0.7.2 → easydetect-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "easydetect"
-version = "0.7.2"
+version = "0.7.3"
 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"

{easydetect-0.7.2 → easydetect-0.7.3}/tests/test_train_export.py

@@ -477,3 +477,20 @@ def test_multiscale_mosaic_and_mixup_train_and_are_recorded(dataset, tmp_path, m
     assert any("mixup" in line for line in setup["augment"])
     assert any("random size, 32–64" in line for line in setup["augment"])
     assert (32, 32) in sizes  # the batches went through at the drawn size
+
+
+def test_fewer_queries_train_and_stay_with_the_model(dataset, tmp_path, monkeypatch):
+    monkeypatch.setattr("easydetect.nn.hgnetv2.HGNetv2.load_imagenet", lambda self, name, url: None)
+    model = Detector("dfine-n", verbose=False, pretrained=False)
+    best = model.train(data=str(dataset), project=str(tmp_path), epochs=1, imgsz=64, batch=2,
+                       workers=0, device="cpu", val=False, amp=False, queries=40, denoising=10)
+    again = Detector(str(best), verbose=False)
+    again._ensure_net()
+    assert again.net.decoder.num_queries == 40 and again.net.decoder.num_denoising == 10
+    # at 160 px the encoder has more than 300 candidates: only the trim limits it
+    onnx = again.export(format="onnx", imgsz=160, out_dir=tmp_path / "x", verbose=False)
+    import onnxruntime as ort
+
+    out = ort.InferenceSession(str(onnx)).run(None, {"images": np.zeros((1, 3, 160, 160),
+                                                                       np.float32)})
+    assert any(o.shape[1] == 40 for o in out if o.ndim == 3)

{easydetect-0.7.2 → easydetect-0.7.3}/tools/bench_finetune.py

@@ -141,14 +141,17 @@ def train_dfine(data: Path, out: Path, args) -> tuple[Path, float]:
     # in a process of its own, as the yolo command is: a crash in what training
     # leaves behind (loader workers, CUDA) then takes only that process down
     started = time.time()
-    code = ("import sys; from easydetect import Detector; "
+    extra = {k: v for k, v in (("queries", args.queries), ("denoising", args.denoising),
+                               ("freeze", args.freeze)) if v is not None}
+    code = ("import json, sys; from easydetect import Detector; "
             "print('BEST', Detector(sys.argv[1], verbose=False).train(data=sys.argv[2], "
             "epochs=int(sys.argv[3]), imgsz=int(sys.argv[4]), batch=int(sys.argv[5]), "
             "patience=int(sys.argv[3]), project=sys.argv[6], name=sys.argv[1], "
-            "workers=int(sys.argv[7])))")
+            "workers=int(sys.argv[7]), **json.loads(sys.argv[8])))")
     best = None
     with subprocess.Popen([sys.executable, "-c", code, args.dfine, str(data), str(args.epochs),
-                           str(args.imgsz), str(args.batch), str(out), str(args.workers)],
+                           str(args.imgsz), str(args.batch), str(out), str(args.workers),
+                           json.dumps(extra)],
                           env=UNBUFFERED, stdout=subprocess.PIPE, text=True) as proc:
         for line in proc.stdout:                    # passed on as it comes
             print(line, end="", flush=True)
@@ -276,6 +279,9 @@ def main():
     parser.add_argument("--yolo", default="yolo26s.pt")
     parser.add_argument("--dfine", default="dfine-s")
     parser.add_argument("--device", default="CPU", help="OpenVINO device for scoring")
+    parser.add_argument("--queries", type=int, help="D-FINE decoder queries (of 300)")
+    parser.add_argument("--denoising", type=int, help="D-FINE denoising queries (100)")
+    parser.add_argument("--freeze", help="D-FINE parts not trained (backbone)")
     parser.add_argument("--rescore", action="store_true",
                         help="score finished datasets again (their trained models are reused)")
     args = parser.parse_args()

{easydetect-0.7.2 → easydetect-0.7.3}/tools/profile_train.py

@@ -35,6 +35,9 @@ def main():
     parser.add_argument("--steps", type=int, default=40)
     parser.add_argument("--warmup", type=int, default=10)
     parser.add_argument("--no-amp", action="store_true")
+    parser.add_argument("--freeze", default=None, help="backbone, encoder, …: parts not trained")
+    parser.add_argument("--queries", type=int, help="decoder queries while training (of 300)")
+    parser.add_argument("--denoising", type=int, help="denoising queries while training (100)")
     parser.add_argument("--trace", action="store_true", help="also PyTorch's operator table")
     parser.add_argument("--syncs", action="store_true",
                         help="list the lines of easydetect where a step waits for the GPU")
@@ -44,9 +47,14 @@ def main():
 
     nc = load_data_yaml(args.data)["nc"]
     net = DFINENet(args.model, nc)
+    if args.queries:
+        net.trim(queries=args.queries)
+    if args.denoising is not None:
+        net.decoder.num_denoising = args.denoising
     with tempfile.TemporaryDirectory() as tmp:
         tr = Trainer(net, args.data, epochs=1, imgsz=args.imgsz, batch=args.batch,
-                     workers=args.workers, project=tmp, amp=not args.no_amp)
+                     workers=args.workers, project=tmp, amp=not args.no_amp,
+                     freeze=args.freeze)
         ds = DetDataset(args.data, "train", args.imgsz, augment=True)
         dl = tr._loader(ds)
         net = tr.net.to(tr.device).train()