easydetect 0.7.0__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: easydetect
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -230,10 +230,32 @@ Read it plainly:
   tasks (oriented boxes, classification, depth), and a far larger ecosystem.
 
 COCO is a guide, not your answer. What matters is the model you get from a
-few hundred pictures of your own: `tools/bench_finetune.py` fine-tunes
-dfine-s and YOLO26s on the same public datasets (from 92 to 1,132 pictures)
-with each trainer's own defaults and scores both with one evaluator on the
-CPU. Its results will be published here.
+few hundred pictures of your own. `tools/bench_finetune.py` fine-tunes
+dfine-s (easydetect 0.7.0) and YOLO26s (Ultralytics 8.4) on the same public
+datasets, each with its own trainer's defaults (100 epochs, 640 px, batch 16,
+one RTX 5090), and scores both with one evaluator on the val split:
+
+| dataset | train pictures | YOLO26s mAP50-95 | dfine-s mAP50-95 | YOLO26s, one class a box | dfine-s, one class a box |
+| --- | --- | --- | --- | --- | --- |
+| african-wildlife | 1,052 | 0.830 | **0.866** | 0.828 | **0.855** |
+| construction-ppe | 1,132 | 0.289 | **0.303** | 0.288 | **0.303** |
+| brain-tumor | 893 | 0.357 | **0.466** | 0.264 | **0.379** |
+| signature | 143 | 0.984 | **0.991** | 0.984 | **0.991** |
+| medical-pills | 92 | 0.801 | **0.806** | 0.801 | **0.806** |
+| african-wildlife, 100 at random | 100 | 0.674 | **0.790** | 0.662 | **0.777** |
+
+| | YOLO26s | dfine-s |
+| --- | --- | --- |
+| inference, a picture (OpenVINO, Core Ultra 5 250K, 640 px) | **23–25 ms** | 28–32 ms |
+| training, 1,000 pictures × 100 epochs (RTX 5090) | **5 min** | 18 min |
+
+* **Accuracy: dfine-s ahead on all six**, by little where both are near the
+  ceiling (signature, pills) and by 11–12 points where it is hard: two
+  look-alike classes (brain-tumor) and 100 pictures for four classes.
+* **YOLO is about 20% faster to run and 3–4× faster to train.**
+* mAP50-95 counts a box for every class it scores, as each project scores
+  itself; "one class a box" is what `predict` hands out. The 100-picture set
+  is noisy: the same code trained twice gave 0.790 and 0.815.
 
 ## Command line
 

{easydetect-0.7.0 → easydetect-0.7.2}/README.md

@@ -187,10 +187,32 @@ Read it plainly:
   tasks (oriented boxes, classification, depth), and a far larger ecosystem.
 
 COCO is a guide, not your answer. What matters is the model you get from a
-few hundred pictures of your own: `tools/bench_finetune.py` fine-tunes
-dfine-s and YOLO26s on the same public datasets (from 92 to 1,132 pictures)
-with each trainer's own defaults and scores both with one evaluator on the
-CPU. Its results will be published here.
+few hundred pictures of your own. `tools/bench_finetune.py` fine-tunes
+dfine-s (easydetect 0.7.0) and YOLO26s (Ultralytics 8.4) on the same public
+datasets, each with its own trainer's defaults (100 epochs, 640 px, batch 16,
+one RTX 5090), and scores both with one evaluator on the val split:
+
+| dataset | train pictures | YOLO26s mAP50-95 | dfine-s mAP50-95 | YOLO26s, one class a box | dfine-s, one class a box |
+| --- | --- | --- | --- | --- | --- |
+| african-wildlife | 1,052 | 0.830 | **0.866** | 0.828 | **0.855** |
+| construction-ppe | 1,132 | 0.289 | **0.303** | 0.288 | **0.303** |
+| brain-tumor | 893 | 0.357 | **0.466** | 0.264 | **0.379** |
+| signature | 143 | 0.984 | **0.991** | 0.984 | **0.991** |
+| medical-pills | 92 | 0.801 | **0.806** | 0.801 | **0.806** |
+| african-wildlife, 100 at random | 100 | 0.674 | **0.790** | 0.662 | **0.777** |
+
+| | YOLO26s | dfine-s |
+| --- | --- | --- |
+| inference, a picture (OpenVINO, Core Ultra 5 250K, 640 px) | **23–25 ms** | 28–32 ms |
+| training, 1,000 pictures × 100 epochs (RTX 5090) | **5 min** | 18 min |
+
+* **Accuracy: dfine-s ahead on all six**, by little where both are near the
+  ceiling (signature, pills) and by 11–12 points where it is hard: two
+  look-alike classes (brain-tumor) and 100 pictures for four classes.
+* **YOLO is about 20% faster to run and 3–4× faster to train.**
+* mAP50-95 counts a box for every class it scores, as each project scores
+  itself; "one class a box" is what `predict` hands out. The 100-picture set
+  is noisy: the same code trained twice gave 0.790 and 0.815.
 
 ## Command line
 

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

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

easydetect-0.7.2/easydetect/benchmark.py

@@ -0,0 +1,147 @@
+# Apache-2.0
+"""How fast each model runs here: ``easydetect benchmark model=a.xml,b.onnx``.
+
+Made for the machine the model will run on (a Raspberry Pi, a mini PC), so it
+needs only the inference dependencies, no PyTorch. Every model is run on every
+runtime that can read it (OpenVINO reads .xml and .onnx, ONNX Runtime .onnx),
+on one picture, ``runs`` times after ``warmup``; the medians of preprocessing,
+inference and decoding are printed as a table, fastest first.
+
+``model=`` takes files, folders (every .xml / .onnx inside, at any depth),
+model names (``dfine-n``: the mirror's ready-made 640 px IR and ONNX), or a
+mix. With no
+``source=`` the picture is a synthetic 640×480 frame, the size a Pi camera
+usually delivers; the time a model takes does not depend on what it sees.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import statistics
+from pathlib import Path
+
+import numpy as np
+
+
+def _model_files(spec) -> list[Path]:
+    items = spec if isinstance(spec, (list, tuple)) else [spec]
+    files: list[Path] = []
+    for item in items:
+        path = Path(str(item)).expanduser()
+        if not path.exists() and _is_name(str(item)):
+            # a model name (dfine-n): the mirror's ready-made IR and ONNX
+            from . import downloads
+
+            fetched = []
+            for fetch in (downloads.download_ir, downloads.download_onnx):
+                try:
+                    fetched.append(fetch(str(item)))
+                except Exception as exc:  # noqa: BLE001 — one format missing is fine
+                    print(f"[easydetect] {item}: {exc}")
+            if not fetched:
+                raise FileNotFoundError(f"could not fetch {item} from the mirror (see above)")
+            files += fetched
+            continue
+        if path.is_dir():
+            files += sorted(p for p in path.rglob("*") if p.suffix in (".xml", ".onnx"))
+        elif path.exists():
+            files.append(path)
+        else:
+            raise FileNotFoundError(f"{path}: no such file or folder")
+    if not files:
+        raise FileNotFoundError(f"no .xml or .onnx models in {spec}")
+    return files
+
+
+def _is_name(text: str) -> bool:
+    from . import downloads
+
+    return downloads.is_model_name(text)
+
+
+def _label(path: Path, spec) -> str:
+    """A model's name in the table: its folder too when the folder says more
+    (pi_kit.py writes ``dfine-n-320-q100/dfine-n.xml``)."""
+    return f"{path.parent.name}/{path.name}" if path.parent.name not in ("", ".") else path.name
+
+
+def _picture(source) -> np.ndarray:
+    if source is None:
+        rng = np.random.default_rng(0)
+        import cv2
+
+        noise = (rng.random((480, 640, 3)) * 255).astype(np.uint8)
+        return cv2.GaussianBlur(noise, (0, 0), 3)
+    import cv2
+
+    img = cv2.imread(str(source))
+    if img is None:
+        raise FileNotFoundError(f"cannot read {source}")
+    return img
+
+
+def _predictor(path: Path, backend: str, device: str, threads: int | None):
+    from .predictor import ORTPredictor, OVPredictor
+
+    if backend == "openvino":
+        return OVPredictor(path, device=device, threads=threads)
+    return ORTPredictor(path, device=device, threads=threads)
+
+
+def benchmark(model, source=None, runs: int = 50, warmup: int = 5,
+              backend: str | list[str] | None = None, device: str = "CPU",
+              threads: int | None = None, verbose: bool = True) -> list[dict]:
+    """Time every model on every runtime; returns one dict a (model, runtime)."""
+    from .predictor import installed
+
+    files = _model_files(model)
+    img = _picture(source)
+    wanted = backend if isinstance(backend, (list, tuple)) else \
+        [backend] if backend else ["openvino", "onnxruntime"]
+    rows = []
+    for path in files:
+        for name in wanted:
+            if not installed(name) or (name == "onnxruntime" and path.suffix != ".onnx"):
+                continue
+            try:
+                predictor = _predictor(path, name, device, threads)
+            except Exception as exc:  # noqa: BLE001 — one model failing must not stop the rest
+                rows.append({"model": _label(path, model), "backend": name,
+                             "error": str(exc)[:120]})
+                continue
+            for _ in range(warmup):
+                predictor(img, conf=0.25)
+            speeds = [predictor(img, conf=0.25)[1] for _ in range(runs)]
+            row = {"model": _label(path, model), "backend": name, "imgsz": predictor.imgsz}
+            for key in ("preprocess", "inference", "postprocess"):
+                row[key] = statistics.median(s[key] for s in speeds)
+            row["total"] = row["preprocess"] + row["inference"] + row["postprocess"]
+            row["fps"] = 1000.0 / row["total"]
+            rows.append(row)
+    rows.sort(key=lambda r: r.get("total", float("inf")))
+    if verbose:
+        print(report(rows, threads))
+    return rows
+
+
+def report(rows: list[dict], threads: int | None = None) -> str:
+    """The table ``benchmark`` prints, with the machine it ran on."""
+    versions = []
+    for module in ("openvino", "onnxruntime"):
+        try:
+            versions.append(f"{module} {__import__(module).__version__}")
+        except ImportError:
+            pass
+    head = (f"{platform.machine()} {platform.system()}, {os.cpu_count()} cores"
+            f"{f', {threads} threads' if threads else ''}; {', '.join(versions)}")
+    lines = [head, f"{'model':40s} {'runtime':12s} {'size':>5s} {'pre':>7s} {'infer':>8s} "
+                   f"{'post':>6s} {'total ms':>9s} {'fps':>6s}"]
+    for r in rows:
+        if "error" in r:
+            lines.append(f"{r['model']:40s} {r['backend']:12s}  failed: {r['error']}")
+            continue
+        lines.append(f"{r['model']:40s} {r['backend']:12s} {r['imgsz']:5d} {r['preprocess']:7.1f} "
+                     f"{r['inference']:8.1f} {r['postprocess']:6.1f} {r['total']:9.1f} "
+                     f"{r['fps']:6.1f}")
+    return "\n".join(lines)

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/cli.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import sys
 from typing import Any
 
-MODES = ("predict", "track", "train", "val", "export", "serve")
+MODES = ("predict", "track", "train", "val", "export", "serve", "benchmark")
 
 HELP = """easydetect — real-time object detection (D-FINE), Apache-2.0
 
@@ -27,6 +27,7 @@ Modes:
   val       COCO-style mAP50 / mAP50-95 on the val split
   export    write an OpenVINO IR (or ONNX) next to the checkpoint
   serve     answer POST /predict with detections as JSON (an HTTP server)
+  benchmark time models on this machine (OpenVINO and ONNX Runtime; no PyTorch needed)
 
 Common keys:
   model=dfine-n|s|m|l|x|best.pt|model.xml   source=bus.jpg|dir|video.mp4|0|url
@@ -41,6 +42,7 @@ Examples:
   easydetect val     model=best.pt data=data.yaml
   easydetect export  model=best.pt format=openvino half=true
   easydetect serve   model=best.onnx host=0.0.0.0 port=8000
+  easydetect benchmark model=pi-kit/ runs=50 threads=4
 """
 
 
@@ -104,6 +106,21 @@ def main(argv: list[str] | None = None) -> int:
         print(HELP, file=sys.stderr)
         return 2
 
+    if mode == "benchmark":
+        from .benchmark import benchmark
+
+        keys = ("model", "source", "runs", "warmup", "backend", "device", "threads")
+        unknown = set(overrides) - set(keys)
+        if unknown or "model" not in overrides:
+            print(f"benchmark takes model= (files or folders) and {', '.join(keys[1:])}",
+                  file=sys.stderr)
+            return 2
+        benchmark(overrides["model"], source=overrides.get("source"),
+                  runs=int(overrides.get("runs", 50)), warmup=int(overrides.get("warmup", 5)),
+                  backend=overrides.get("backend"), device=str(overrides.get("device", "CPU")),
+                  threads=overrides.get("threads"))
+        return 0
+
     if mode == "serve":
         from .serve import serve
 

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/downloads.py

@@ -80,10 +80,23 @@ def download(url: str, dest: Path, progress: bool = True) -> Path:
     tmp = dest.with_suffix(dest.suffix + f".{os.getpid()}.part")
     request = urllib.request.Request(url, headers={"User-Agent": "easydetect"})
     digest = hashlib.sha256()
+    linked: dict[str, str] = {}
+
+    class _Remember(urllib.request.HTTPRedirectHandler):
+        """Hugging Face states a large file's SHA-256 in ``X-Linked-Etag`` on
+        the redirect to its storage; the storage's own ``ETag`` is some other
+        hash. Keep the first, never trust the second."""
+
+        def redirect_request(self, req, fp, code, msg, headers, newurl):
+            if headers.get("X-Linked-Etag"):
+                linked.setdefault("etag", headers["X-Linked-Etag"])
+            return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+    opener = urllib.request.build_opener(_Remember)
     try:
-        with urllib.request.urlopen(request, timeout=_TIMEOUT) as response, open(tmp, "wb") as out:
+        with opener.open(request, timeout=_TIMEOUT) as response, open(tmp, "wb") as out:
             total = int(response.headers.get("Content-Length") or 0)
-            tag = (response.headers.get("X-Linked-Etag") or response.headers.get("ETag") or "")
+            tag = linked.get("etag") or response.headers.get("X-Linked-Etag") or ""
             expected = re.fullmatch(r'(?:W/)?"?([0-9a-f]{64})"?', tag.strip())
             done = 0
             while chunk := response.read(1 << 16):

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/nn/decoder.py

@@ -757,7 +757,12 @@ class DFINETransformer(nn.Module):
     ):
         # prepare input for decoder
         if self.training or self.eval_spatial_size is None:
-            anchors, valid_mask = self._generate_anchors(spatial_shapes, device=memory.device)
+            # the same for every step at a given size: built once (as above)
+            key = (tuple(map(tuple, spatial_shapes)), memory.device)
+            cache = self.__dict__.setdefault("_anchor_cache", {})
+            if key not in cache:
+                cache[key] = self._generate_anchors(spatial_shapes, device=memory.device)
+            anchors, valid_mask = cache[key]
         else:
             anchors = self.anchors
             valid_mask = self.valid_mask

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/nn/denoising.py

@@ -86,7 +86,7 @@ def get_contrastive_denoising_training_group(
         known_bbox += rand_sign * rand_part * diff
         known_bbox = torch.clip(known_bbox, min=0.0, max=1.0)
         input_query_bbox = box_xyxy_to_cxcywh(known_bbox)
-        input_query_bbox[input_query_bbox < 0] *= -1
+        input_query_bbox = input_query_bbox.abs()
         input_query_bbox_unact = inverse_sigmoid(input_query_bbox)
 
     input_query_logits = class_embed(input_query_class)

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/nn/encoder.py

@@ -448,9 +448,16 @@ class HybridEncoder(nn.Module):
                 # flatten [B, C, H, W] to [B, HxW, C]
                 src_flatten = proj_feats[enc_ind].flatten(2).permute(0, 2, 1)
                 if self.training or self.eval_spatial_size is None:
-                    pos_embed = self.build_2d_sincos_position_embedding(
-                        w, h, self.hidden_dim, self.pe_temperature
-                    ).to(src_flatten.device)
+                    # the same for every step at a given size: built once, kept
+                    # on the device (it was rebuilt on the CPU and copied over
+                    # every training step)
+                    key = (w, h, src_flatten.device)
+                    cache = self.__dict__.setdefault("_pos_cache", {})
+                    if key not in cache:
+                        cache[key] = self.build_2d_sincos_position_embedding(
+                            w, h, self.hidden_dim, self.pe_temperature
+                        ).to(src_flatten.device)
+                    pos_embed = cache[key]
                 else:
                     pos_embed = getattr(self, f"pos_embed{enc_ind}", None).to(src_flatten.device)
 

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/nn/ops.py

@@ -185,10 +185,9 @@ def generalized_box_iou(boxes1, boxes2):
     Returns a [N, M] pairwise matrix, where N = len(boxes1)
     and M = len(boxes2)
     """
-    # degenerate boxes gives inf / nan results
-    # so do an early check
-    assert (boxes1[:, 2:] >= boxes1[:, :2]).all()
-    assert (boxes2[:, 2:] >= boxes2[:, :2]).all()
+    # degenerate boxes give inf / nan; the boxes here come from cx cy w h
+    # with w, h >= 0, so they never are (the check D-FINE had made every call
+    # wait for the GPU)
     iou, union = box_iou(boxes1, boxes2)
 
     lt = torch.min(boxes1[:, None, :2], boxes2[:, :2])
@@ -322,22 +321,23 @@ def translate_gt(gt, reg_max, reg_scale, up):
     # Calculate the weights for the interpolation
     indices = closest_left_indices.float()
 
-    weight_right = torch.zeros_like(indices)
-    weight_left = torch.zeros_like(indices)
-
+    # computed for every value and kept where valid (torch.where), rather
+    # than gathered through a boolean mask: a mask's size is only known once
+    # the GPU has computed it, so selecting with one makes the step wait
     valid_idx_mask = (indices >= 0) & (indices < reg_max)
-    valid_indices = indices[valid_idx_mask].long()
+    safe = indices.clamp(0, reg_max - 1).long()
 
     # Obtain distances
-    left_values = function_values[valid_indices]
-    right_values = function_values[valid_indices + 1]
+    left_values = function_values[safe]
+    right_values = function_values[safe + 1]
 
-    left_diffs = torch.abs(gt[valid_idx_mask] - left_values)
-    right_diffs = torch.abs(right_values - gt[valid_idx_mask])
+    left_diffs = torch.abs(gt - left_values)
+    right_diffs = torch.abs(right_values - gt)
 
     # Valid weights
-    weight_right[valid_idx_mask] = left_diffs / (left_diffs + right_diffs)
-    weight_left[valid_idx_mask] = 1.0 - weight_right[valid_idx_mask]
+    right = left_diffs / (left_diffs + right_diffs)
+    weight_right = torch.where(valid_idx_mask, right, torch.zeros_like(right))
+    weight_left = torch.where(valid_idx_mask, 1.0 - right, torch.zeros_like(right))
 
     # Invalid weights (out of range)
     invalid_idx_mask_neg = indices < 0

{easydetect-0.7.0 → easydetect-0.7.2}/easydetect/predictor.py

@@ -401,8 +401,10 @@ class OVPredictor(Predictor):
         imgsz: int | None = None,
         names: dict[int, str] | None = None,
         precision: str | None = None,
+        threads: int | None = None,
     ) -> None:
-        """``precision`` overrides what OpenVINO runs the graph in.
+        """``precision`` overrides what OpenVINO runs the graph in;
+        ``threads`` caps the CPU threads it uses (default: all cores).
 
         Left alone, OpenVINO picks: on a CPU that supports it that means
         bfloat16, which is much faster but shifts scores slightly. Pass
@@ -414,6 +416,8 @@ class OVPredictor(Predictor):
         core = ov_core()
         model = core.read_model(str(self.model_path))
         config = {"INFERENCE_PRECISION_HINT": precision} if precision else {}
+        if threads and "CPU" in device.upper():
+            config["INFERENCE_NUM_THREADS"] = int(threads)
         self.compiled = core.compile_model(model, device, config)
         self.input = self.compiled.input(0)
         # CompiledModel.__call__ reuses one InferRequest, so a second thread

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

@@ -44,14 +44,19 @@ BASE_SIZE_REPEAT = 3  # how often imgsz itself is listed among the multi-scale s
 EMA_RESTART_STEP = 0.0001  # the average's decay is lowered this much after the best is reloaded
 
 
-def _float32(out):
-    """The network's outputs, every floating tensor in them as float32."""
+def _float32(out, _seen=None):
+    """The network's outputs, every floating tensor in them as float32. A
+    tensor that appears twice is converted once and stays one object (the loss
+    tells a layer that is its own teacher by identity)."""
+    seen = {} if _seen is None else _seen
     if isinstance(out, torch.Tensor):
-        return out.float() if out.is_floating_point() else out
+        if id(out) not in seen:
+            seen[id(out)] = (out, out.float() if out.is_floating_point() else out)
+        return seen[id(out)][1]
     if isinstance(out, dict):
-        return {k: _float32(v) for k, v in out.items()}
+        return {k: _float32(v, seen) for k, v in out.items()}
     if isinstance(out, (list, tuple)):
-        return type(out)(_float32(v) for v in out)
+        return type(out)(_float32(v, seen) for v in out)
     return out
 
 
@@ -297,6 +302,13 @@ class Trainer:
         self.device = torch.device(device or ("cuda" if torch.cuda.is_available() else "cpu"))
         self.workers = workers
         self.amp = amp and self.device.type == "cuda"
+        if self.device.type == "cuda":
+            # the input size is fixed (or one of a few, multi-scale): let cuDNN
+            # time its convolution algorithms once and keep the fastest; and
+            # let float32 matmuls (the loss, the parts autocast leaves) use TF32
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
         # bfloat16 where the GPU has it (RTX 30 and later): float32's range, so
         # no loss scaling and no overflow; float16 with a GradScaler otherwise
         self.amp_dtype = (torch.bfloat16 if self.amp and torch.cuda.is_bf16_supported()
@@ -318,8 +330,16 @@ class Trainer:
         if lr_backbone_mult is None:
             lr_backbone_mult = BACKBONE_LR_MULT.get(getattr(net, "variant", ""), 0.1)
         self.lr_backbone_mult = lr_backbone_mult
+        if self.device.type == "cuda":
+            # convolutions in channels-last (NHWC): what the GPU's tensor cores
+            # want, so cuDNN no longer converts every activation back and forth
+            # (an RTX 5090, dfine-s at batch 16: 117 -> 100 ms a step)
+            net.to(self.device, memory_format=torch.channels_last)
+        self.channels_last = self.device.type == "cuda"
         self.opt = torch.optim.AdamW(
-            _param_groups(net, lr, lr * lr_backbone_mult), lr=lr, weight_decay=weight_decay
+            _param_groups(net, lr, lr * lr_backbone_mult), lr=lr, weight_decay=weight_decay,
+            # one kernel for every parameter on a GPU, instead of a few per tensor
+            fused=self.device.type == "cuda",
         )
         self.criterion = DetectionLoss(net.num_classes, reg_max=net.decoder.reg_max)
         self.ema = ModelEMA(net)
@@ -597,6 +617,8 @@ class Trainer:
                     if side != imgs.shape[-1]:
                         imgs = torch.nn.functional.interpolate(
                             imgs, size=(side, side), mode="bilinear", align_corners=False)
+                if self.channels_last:
+                    imgs = imgs.contiguous(memory_format=torch.channels_last)
                 targets = [{k: v.to(self.device) for k, v in t.items()} for t in targets]
 
                 with torch.amp.autocast(self.device.type, dtype=self.amp_dtype,