Replace with RF-DETR-Large NL plate detector (ONNX, Apache 2.0)

LICENSE

@@ -0,0 +1,19 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Rick Kosse
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   Full license text: https://www.apache.org/licenses/LICENSE-2.0.txt

README.md

@@ -1,122 +1,81 @@
 ---
 license: apache-2.0
-task_categories:
-- object-detection
+library_name: rfdetr
+pipeline_tag: object-detection
+base_model: roboflow/rf-detr-large
 tags:
-- license-plate
-- netherlands
-- rf-detr
-- onnx
-- european
-language:
-- nl
+  - object-detection
+  - license-plate-detection
+  - alpr
+  - rf-detr
+  - onnx
+  - netherlands
 ---
 
-# RF-DETR License Plate Detector
-RF-DETR Base fine-tuned for license plate detection with a single class: `license_plate`.  
-Trained primarily on Dutch plates but generalises well to other European formats.
+# RF-DETR-Large — Dutch License Plate Detector
 
-**GitHub**: [rickkosse/dutch-license-plate-detector](https://github.com/rickkosse/dutch-license-plate-detector)
+A single-class license-plate **detector** fine-tuned from
+[`roboflow/rf-detr-large`](https://huggingface.co/roboflow/rf-detr-large) on Dutch +
+synthetic plate data, exported to ONNX (fixed 768×768 input).
 
-## Files
-- **`inference_model.onnx`** — ONNX export for CPU inference via ONNX Runtime  
-- **`checkpoint_best_ema_v4.pth`** — PyTorch EMA checkpoint for fine-tuning
+- **Task:** license-plate detection (one class: `license_plate`)
+- **Base model:** RF-DETR-Large (Apache 2.0)
+- **Input:** `[1, 3, 768, 768]` RGB, ImageNet-normalized
+- **Outputs:** `dets` (boxes, cx/cy/w/h normalized) and `labels` (per-query scores)
+- **License:** Apache 2.0
 
-## Usage — ONNX (Recommended)
+## Live demo
+Try it in the Space: **[Rickkosse/license-plate-detector](https://huggingface.co/spaces/Rickkosse/license-plate-detector)**
+(detection + `fast-plate-ocr` reading, with an "unreadable" gate for low-confidence plates).
 
-```python
-import cv2
-import numpy as np
-import onnxruntime as ort
-
-session = ort.InferenceSession("inference_model.onnx",
-                                providers=["CPUExecutionProvider"])
-
-def preprocess(img_bgr, size=784):
-    img = cv2.resize(img_bgr, (size, size))
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
-    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
-    std  = np.array([0.229, 0.224, 0.225], dtype=np.float32)
-    return ((img - mean) / std).transpose(2, 0, 1)[np.newaxis]  # NCHW
-
-img = cv2.imread("photo.jpg")
-oh, ow = img.shape[:2]
-outputs = session.run(None, {session.get_inputs()[0].name: preprocess(img)})
-
-dets   = outputs[0].squeeze()   # (300, 4) cxcywh normalised
-logits = outputs[1].squeeze()   # (300, 2) raw logits
-s0 = 1 / (1 + np.exp(-logits[:, 0]))
-s1 = 1 / (1 + np.exp(-logits[:, 1]))
-scores = s0 if s0.max() > s1.max() else s1  # pick the plate-class column
-
-for i in np.where(scores > 0.3)[0]:
-    cx, cy, bw, bh = dets[i]
-    x1 = int((cx - bw / 2) * ow); y1 = int((cy - bh / 2) * oh)
-    x2 = int((cx + bw / 2) * ow); y2 = int((cy + bh / 2) * oh)
-    print(f"Plate: ({x1},{y1},{x2},{y2})  conf={scores[i]:.2f}")
-    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
-
-cv2.imwrite("result.jpg", img)
-```
-
-## Post-processing
-
-Geometry filter (recommended):
-
-```python
-w, h = x2 - x1, y2 - y1
-if h <= 0 or not (1.5 <= w / h <= 9.0):
-    continue   # wrong aspect ratio
-if (w * h) / (ow * oh) > 0.15:
-    continue   # too large
-```
+## Intended use & limitations
+Detects Dutch-style plates well when they are reasonably large and frontal. Small,
+distant, or strongly angled plates in wide scenes are harder (a known data-coverage
+limitation). This is a **prototype**: training data was cc-by-nc / synthetic, so it
+is not a certified production model. For production, retrain on rights-clean,
+hand-verified data — the pipeline is unchanged.
 
-## OCR with `fast-plate-ocr`
+## Usage (ONNX Runtime)
 
 ```python
-from fast_plate_ocr import LicensePlateRecognizer
-
-ocr = LicensePlateRecognizer("european-plates-mobile-vit-v2-model")
-crop = cv2.cvtColor(img[y1:y2, x1:x2], cv2.COLOR_BGR2GRAY)[:, :, np.newaxis]
-result = ocr.run(crop)
-text = result[0].plate.strip() if result and result[0].plate else ""
-```
-
-## Optional format validation (Dutch example — adapt for your country)
-
-```python
-import re
-
-NL_PLATE = re.compile(
-    r'^[A-Z]{2}\d{2}[A-Z]{2}$|^\d{2}[A-Z]{2}\d{2}$|^[A-Z]{4}\d{2}$|'
-    r'^\d{4}[A-Z]{2}$|^\d{2}[A-Z]{4}$|^[A-Z]{2}\d{4}$|'
-    r'^[A-Z]{2}\d{3}[A-Z]$|^[A-Z]\d{3}[A-Z]{2}$|'
-    r'^[A-Z]{3}\d{2}[A-Z]$|^[A-Z]\d{2}[A-Z]{3}$|'
-    r'^\d{2}[A-Z]{3}\d$|^\d[A-Z]{3}\d{2}$',
-    re.IGNORECASE,
-)
-
-if not NL_PLATE.match(text.replace("-", "").upper()):
-    continue   # skip if format doesn't match — omit this check for other countries
-```
-
-## Training Details
-
-| | |
-|---|---|
-| Architecture | RF-DETR Base, 1 class (`license_plate`) |
-| Resolution | 784×784 |
-| Optimizer | AdamW, LR 5e-5, encoder LR 1e-5 |
-| Scheduler | Cosine annealing + 5 warmup epochs |
-| EMA | Enabled |
-| Data | Synthetic plates on BDD100K + real-world crops |
-
-## Installation
-
-```bash
-pip install onnxruntime fast-plate-ocr opencv-python
+import numpy as np, onnxruntime as ort
+from PIL import Image
+
+RES = 768
+MEAN = np.array([0.485, 0.456, 0.406], np.float32)
+STD  = np.array([0.229, 0.224, 0.225], np.float32)
+
+sess = ort.InferenceSession("rfdetr-large.onnx", providers=ort.get_available_providers())
+in_name = sess.get_inputs()[0].name
+
+def detect(path, conf=0.5):
+    pil = Image.open(path).convert("RGB")
+    w0, h0 = pil.size
+    img = pil.resize((RES, RES), Image.BILINEAR)
+    x = (np.asarray(img, np.float32) / 255.0 - MEAN) / STD
+    x = np.ascontiguousarray(x.transpose(2, 0, 1)[None], np.float32)
+    dets, labels = sess.run(["dets", "labels"], {in_name: x})
+    d = dets[0] if dets.ndim == 3 else dets
+    l = labels[0] if labels.ndim == 3 else labels
+    scores = l.max(axis=-1) if l.ndim > 1 else l
+    if scores.max() > 1 or scores.min() < 0:
+        scores = 1 / (1 + np.exp(-scores))          # logits -> prob
+    out = []
+    for (cx, cy, bw, bh), s in zip(d, scores):
+        if s < conf:
+            continue
+        out.append((max(0,(cx-bw/2)*w0), max(0,(cy-bh/2)*h0),
+                    min(w0,(cx+bw/2)*w0), min(h0,(cy+bh/2)*h0), float(s)))
+    return out
+
+print(detect("car.jpg"))   # [(x1, y1, x2, y2, score), ...] in pixels
 ```
 
-## License
+## Reading plates (optional, two-stage ALPR)
+Pair detection with [`fast-plate-ocr`](https://github.com/ankandrew/fast-plate-ocr)
+(MIT): crop each detected box and read it. The OCR expects a **grayscale** crop with
+a channel axis `(H, W, 1)`. See the Space `app.py` for a full example, including the
+confidence gate that flags unreadable plates instead of guessing.
 
-Apache 2.0
+## Citation
+Built on RF-DETR by Roboflow. OCR by `fast-plate-ocr` (ankandrew).

inference.py

@@ -0,0 +1,40 @@
+"""Minimal RF-DETR ONNX license-plate detector. License: Apache 2.0."""
+import argparse
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+
+RES = 768
+MEAN = np.array([0.485, 0.456, 0.406], np.float32)
+STD = np.array([0.229, 0.224, 0.225], np.float32)
+
+
+def detect(sess, in_name, pil, conf=0.5):
+    w0, h0 = pil.size
+    img = pil.convert("RGB").resize((RES, RES), Image.BILINEAR)
+    x = (np.asarray(img, np.float32) / 255.0 - MEAN) / STD
+    x = np.ascontiguousarray(x.transpose(2, 0, 1)[None], np.float32)
+    dets, labels = sess.run(["dets", "labels"], {in_name: x})
+    d = dets[0] if dets.ndim == 3 else dets
+    l = labels[0] if labels.ndim == 3 else labels
+    scores = l.max(axis=-1) if l.ndim > 1 else l
+    if scores.max() > 1 or scores.min() < 0:
+        scores = 1 / (1 + np.exp(-scores))
+    out = []
+    for (cx, cy, bw, bh), s in zip(d, scores):
+        if s < conf:
+            continue
+        out.append((max(0, (cx - bw / 2) * w0), max(0, (cy - bh / 2) * h0),
+                    min(w0, (cx + bw / 2) * w0), min(h0, (cy + bh / 2) * h0), float(s)))
+    return out
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("image")
+    ap.add_argument("--onnx", default="rfdetr-large.onnx")
+    ap.add_argument("--conf", type=float, default=0.5)
+    args = ap.parse_args()
+    sess = ort.InferenceSession(args.onnx, providers=ort.get_available_providers())
+    for box in detect(sess, sess.get_inputs()[0].name, Image.open(args.image), args.conf):
+        print(f"x1={box[0]:.0f} y1={box[1]:.0f} x2={box[2]:.0f} y2={box[3]:.0f} score={box[4]:.2f}")

inference_model.onnx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5886b25016751238979c21336bae2b02b944b0db07f544e14ec5311191f934b7
-size 115501245

requirements.txt

@@ -0,0 +1,3 @@
+onnxruntime
+numpy
+pillow

checkpoint_best_ema_v4.pth → rfdetr-large.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:73b8efc467c728dc75854494fc8158cca75c503993402b382b59916f40995b28
-size 127629096
+oid sha256:f2f6f93c64c5844246ed343b00b298b4dc01ba377912d462bc4882da0816c012
+size 128345033