Update app.py

app.py

@@ -70,7 +70,7 @@ class QCConfig:
     weights:     str | None
     cpu_count:   int = CPU_COUNT
     batch_size:  int = BATCH_SIZE
-    sample_limit: int = SAMPLE_LIMIT
+    sample_limit:int = SAMPLE_LIMIT
 
 # ─────────── Helpers & Caching ─────────────────────────────────────────────
 def load_yaml(path: Path) -> Dict:
@@ -171,12 +171,12 @@ def qc_class_balance(lbls: List[Path], cfg: QCConfig) -> Dict:
         boxes.append(len(bs))
         counts.update(b[0] for b in bs)
     if not counts:
-        return {"name": "Class balance", "score": 0, "details": "No labels"}
+        return {"name":"Class balance","score":0,"details":"No labels"}
     bal = min(counts.values()) / max(counts.values()) * 100
     return {
-        "name": "Class balance",
-        "score": bal,
-        "details": {
+        "name":"Class balance",
+        "score":bal,
+        "details":{
             "class_counts": dict(counts),
             "boxes_per_image": {
                 "min": min(boxes),
@@ -188,7 +188,7 @@ def qc_class_balance(lbls: List[Path], cfg: QCConfig) -> Dict:
 
 def qc_image_quality(imgs: List[Path], cfg: QCConfig) -> Dict:
     if cv2 is None:
-        return {"name": "Image quality", "score": 100, "details": "cv2 missing"}
+        return {"name":"Image quality","score":100,"details":"cv2 missing"}
     blurry, dark, bright = [], [], []
     sample = imgs[:cfg.sample_limit]
     with ThreadPoolExecutor(max_workers=cfg.cpu_count) as ex:
@@ -200,9 +200,9 @@ def qc_image_quality(imgs: List[Path], cfg: QCConfig) -> Dict:
     bad = len({*blurry, *dark, *bright})
     score = 100 - bad / max(len(sample), 1) * 100
     return {
-        "name": "Image quality",
-        "score": score,
-        "details": {
+        "name":"Image quality",
+        "score":score,
+        "details":{
             "blurry": [str(p) for p in blurry],
             "dark":   [str(p) for p in dark],
             "bright": [str(p) for p in bright]
@@ -217,12 +217,28 @@ def qc_duplicates(imgs: List[Path], cfg: QCConfig) -> Dict:
                 work_dir=str(TMP_ROOT / "fastdup")
             )
             fd.run()
-            cc = fd.connected_components_grouped(sort_by="comp_size", ascending=False)
-            clusters = cc["files"].tolist()
+
+            # Try the grouped-DataFrame API first:
+            try:
+                cc = fd.connected_components_grouped(sort_by="comp_size", ascending=False)
+                if "files" in cc.columns:
+                    clusters = cc["files"].tolist()
+                else:
+                    # fallback: group by component ID, collect filenames
+                    clusters = (
+                        cc.groupby("component")["filename"]
+                          .apply(list)
+                          .tolist()
+                    )
+            except Exception:
+                # final fallback to the old list-based API
+                clusters = fd.connected_components()
+
             dup = sum(len(c) - 1 for c in clusters)
+            score = max(0.0, 100 - dup / len(imgs) * 100)
             return {
                 "name": "Duplicates",
-                "score": max(0.0, 100 - dup / len(imgs) * 100),
+                "score": score,
                 "details": {"groups": clusters[:50]}
             }
         except Exception as e:
@@ -236,14 +252,14 @@ def qc_duplicates(imgs: List[Path], cfg: QCConfig) -> Dict:
 def qc_model_qa(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
     model = get_model(cfg.weights)
     if model is None:
-        return {"name": "Model QA", "score": 100, "details": "skipped"}
+        return {"name":"Model QA","score":100,"details":"skipped"}
     ious, mism = [], []
     sample = imgs[:cfg.sample_limit]
     for i in range(0, len(sample), cfg.batch_size):
-        batch = sample[i:i + cfg.batch_size]
+        batch = sample[i:i+cfg.batch_size]
         results = model.predict(batch, verbose=False, half=True, dynamic=True)
         for p, res in zip(batch, results):
-            gt = parse_label_file(Path(p).parent.parent / 'labels' / f"{Path(p).stem}.txt")
+            gt = parse_label_file(Path(p).parent.parent/'labels'/f"{Path(p).stem}.txt")
             for cls, x, y, w, h in gt:
                 best = 0.0
                 for b, c, conf in zip(
@@ -259,14 +275,14 @@ def qc_model_qa(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
                     mism.append(str(p))
     miou = float(np.mean(ious)) if ious else 1.0
     return {
-        "name": "Model QA",
-        "score": miou * 100,
-        "details": {"mean_iou": miou, "mismatches": mism[:50]}
+        "name":"Model QA",
+        "score":miou*100,
+        "details":{"mean_iou":miou, "mismatches":mism[:50]}
     }
 
 def qc_label_issues(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
     if get_noise_indices is None:
-        return {"name": "Label issues", "score": 100, "details": "skipped"}
+        return {"name":"Label issues","score":100,"details":"skipped"}
     labels, idxs = [], []
     sample = imgs[:cfg.sample_limit]
     for i, p in enumerate(sample):
@@ -275,35 +291,35 @@ def qc_label_issues(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
             labels.append(int(cls))
             idxs.append(i)
     if not labels:
-        return {"name": "Label issues", "score": 100, "details": "no GT"}
+        return {"name":"Label issues","score":100,"details":"no GT"}
     labels_arr = np.array(labels)
     uniq       = sorted(set(labels_arr))
     probs      = np.eye(len(uniq))[np.searchsorted(uniq, labels_arr)]
     noise      = get_noise_indices(labels=labels_arr, probabilities=probs)
     flags      = sorted({idxs[n] for n in noise})
     files      = [str(sample[i]) for i in flags]
-    score      = 100 - len(flags) / len(labels) * 100
+    score      = 100 - len(flags)/len(labels)*100
     return {
-        "name": "Label issues",
-        "score": score,
-        "details": {"files": files[:50]}
+        "name":"Label issues",
+        "score":score,
+        "details":{"files":files[:50]}
     }
 
 def _rel_iou(b1, b2):
     x1, y1, w1, h1 = b1
     x2, y2, w2, h2 = b2
-    xa1, ya1 = x1 - w1/2, y1 - h1/2
-    xa2, ya2 = x1 + w1/2, y1 + h1/2
-    xb1, yb1 = x2 - w2/2, y2 - h2/2
-    xb2, yb2 = x2 + w2/2, y2 + h2/2
+    xa1, ya1 = x1-w1/2, y1-h1/2
+    xa2, ya2 = x1+w1/2, y1+h1/2
+    xb1, yb1 = x2-w2/2, y2-h2/2
+    xb2, yb2 = x2+w2/2, y2+h2/2
     ix1 = max(xa1, xb1); iy1 = max(ya1, yb1)
     ix2 = min(xa2, xb2); iy2 = min(ya2, yb2)
-    inter = max(ix2 - ix1, 0) * max(iy2 - iy1, 0)
-    union = w1 * h1 + w2 * h2 - inter
-    return inter / union if union else 0.0
+    inter = max(ix2-ix1, 0) * max(iy2-iy1, 0)
+    union = w1*h1 + w2*h2 - inter
+    return inter/union if union else 0.0
 
 def aggregate(results: List[Dict]) -> float:
-    return sum(DEFAULT_W[r["name"]] * r["score"] for r in results)
+    return sum(DEFAULT_W[r["name"]]*r["score"] for r in results)
 
 RF_RE = re.compile(r"https?://universe\.roboflow\.com/([^/]+)/([^/]+)/dataset/(\d+)")
 
@@ -312,7 +328,7 @@ def download_rf_dataset(url: str, rf_api: Roboflow, dest: Path) -> Path:
     if not m:
         raise ValueError(f"Bad RF URL: {url}")
     ws, proj, ver = m.groups()
-    ds_dir = dest / f"{ws}_{proj}_v{ver}"
+    ds_dir = dest/f"{ws}_{proj}_v{ver}"
     if ds_dir.exists():
         return ds_dir
     pr = rf_api.workspace(ws).project(proj)
@@ -332,9 +348,9 @@ def run_quality(
         qc_integrity(imgs, lbls, cfg),
         qc_class_balance(lbls, cfg),
         qc_image_quality(imgs, cfg),
-        qc_duplicates(imgs, cfg)      if run_dup     else {"name": "Duplicates", "score": 100, "details": "skipped"},
-        qc_model_qa(imgs, lbls, cfg)  if run_modelqa else {"name": "Model QA",   "score": 100, "details": "skipped"},
-        qc_label_issues(imgs, lbls, cfg) if run_modelqa else {"name": "Label issues", "score": 100, "details": "skipped"},
+        qc_duplicates(imgs, cfg)      if run_dup     else {"name":"Duplicates","score":100,"details":"skipped"},
+        qc_model_qa(imgs, lbls, cfg)  if run_modelqa else {"name":"Model QA","score":100,"details":"skipped"},
+        qc_label_issues(imgs, lbls, cfg) if run_modelqa else {"name":"Label issues","score":100,"details":"skipped"},
     ]
     final = aggregate(results)
 
@@ -398,9 +414,9 @@ with gr.Blocks(title="YOLO Dataset Quality Evaluator v3") as demo:
                 if not line.strip():
                     continue
                 try:
-                    ds, md, df = download_rf_dataset(line, rf, TMP_ROOT), *run_quality(
-                        download_rf_dataset(line, rf, TMP_ROOT),
-                        None,
+                    ds = download_rf_dataset(line, rf, TMP_ROOT)
+                    md, df = run_quality(
+                        ds, None,
                         Path(weights.name) if weights else None,
                         cfg, run_dup, run_modelqa
                     )