Update app.py

app.py

@@ -4,11 +4,11 @@ app.py – Roboflow‑aware YOLOv8 Dataset Quality Evaluator (v3)
 Changelog (2025‑04‑17)
 ──────────────────────
 • Fix RF URL regex to accept http/https
-• Use top-level helper functions instead of lambdas for ProcessPoolExecutor
-• Introduce _quality_stat_args and _compute_hash to ensure picklability
+• Top-level functions for parallel mapping (picklable)
+• Fastdup-only path in qc_duplicates (skips hashing fallback)
 • YOLO model caching
 • Config dataclass & Gradio sliders for blur, IOU, confidence
-• Cleanlab integration for label issue detection
+• Cleanlab integration for label-issue detection
 """
 
 from __future__ import annotations
@@ -97,13 +97,13 @@ def parse_label_file(path: Path) -> list[tuple[int, float, float, float, float]]
         if arr.ndim == 1:
             arr = arr.reshape(1, -1)
         return [tuple(row) for row in arr]
-    except Exception:
+    except:
         return []
 
 def guess_image_dirs(root: Path) -> List[Path]:
-    subs = [root/'images', root/'train'/'images', root/'valid'/'images',
-            root/'val'/'images', root/'test'/'images']
-    return [d for d in subs if d.exists()]
+    candidates = [root/'images', root/'train'/'images', root/'valid'/'images',
+                  root/'val'/'images',   root/'test'/'images']
+    return [d for d in candidates if d.exists()]
 
 def gather_dataset(root: Path, yaml_path: Path | None):
     if yaml_path is None:
@@ -116,13 +116,13 @@ def gather_dataset(root: Path, yaml_path: Path | None):
     if not img_dirs:
         raise FileNotFoundError("images/ directory missing")
     imgs = [p for d in img_dirs for p in d.rglob('*.*') if imghdr.what(p)]
-    labels_root = {d.parent/'labels' for d in img_dirs}
-    lbls = [next((lr/f"{p.stem}.txt" for lr in labels_root if (lr/f"{p.stem}.txt").exists()), None)
+    labels_roots = {d.parent/'labels' for d in img_dirs}
+    lbls = [next((lr/f"{p.stem}.txt" for lr in labels_roots if (lr/f"{p.stem}.txt").exists()), None)
             for p in imgs]
     return imgs, lbls, meta
 
 def get_model(weights: str) -> YOLO | None:
-    if weights is None or YOLO is None:
+    if not weights or YOLO is None:
         return None
     if weights not in _model_cache:
         _model_cache[weights] = YOLO(weights)
@@ -130,7 +130,7 @@ def get_model(weights: str) -> YOLO | None:
 
 # ───────── Functions for parallel mapping ──────────────────────────────────
 def _quality_stat_args(args: Tuple[Path, float]) -> Tuple[Path, bool, bool, bool]:
-    path, blur_thr = args
+    path, thr = args
     if cv2 is None:
         return path, False, False, False
     im = cv2.imread(str(path))
@@ -138,11 +138,8 @@ def _quality_stat_args(args: Tuple[Path, float]) -> Tuple[Path, bool, bool, bool
         return path, False, False, False
     gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
     lap = cv2.Laplacian(gray, cv2.CV_64F).var()
-    br = gray.mean()
-    return path, lap < blur_thr, br < 25, br > 230
-
-def _compute_hash(path: Path) -> str:
-    return str(imagehash.average_hash(Image.open(path)))
+    mean = gray.mean()
+    return path, lap < thr, mean < 25, mean > 230
 
 def _is_corrupt(path: Path) -> bool:
     try:
@@ -154,19 +151,19 @@ def _is_corrupt(path: Path) -> bool:
 
 # ───────────────── Quality Checks ──────────────────────────────────────────
 def qc_integrity(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
-    missing = [i for i, l in zip(imgs, lbls) if l is None]
+    missing = [i for i,l in zip(imgs,lbls) if l is None]
     corrupt = []
     with ProcessPoolExecutor(max_workers=cfg.cpu_count) as ex:
         fut = {ex.submit(_is_corrupt, p): p for p in imgs}
         for f in as_completed(fut):
             if f.result(): corrupt.append(fut[f])
-    score = 100 - (len(missing) + len(corrupt)) / max(len(imgs), 1) * 100
+    score = 100 - (len(missing)+len(corrupt))/max(len(imgs),1)*100
     return {"name":"Integrity","score":max(score,0),
             "details":{"missing_label_files":[str(p) for p in missing],
                        "corrupt_images":[str(p) for p in corrupt]}}
 
 def qc_class_balance(lbls: List[Path], cfg: QCConfig) -> Dict:
-    counts = Counter(); boxes = []
+    counts, boxes = Counter(), []
     for l in lbls:
         bs = parse_label_file(l) if l else []
         boxes.append(len(bs)); counts.update(b[0] for b in bs)
@@ -175,67 +172,69 @@ def qc_class_balance(lbls: List[Path], cfg: QCConfig) -> Dict:
     bal = min(counts.values())/max(counts.values())*100
     return {"name":"Class balance","score":bal,
             "details":{"class_counts":dict(counts),
-                       "boxes_per_image":{"min":min(boxes),"max":max(boxes),"mean":float(np.mean(boxes))}}}
+                       "boxes_per_image":{
+                           "min":min(boxes),"max":max(boxes),
+                           "mean":float(np.mean(boxes))}}}
 
 def qc_image_quality(imgs: List[Path], cfg: QCConfig) -> Dict:
     if cv2 is None:
         return {"name":"Image quality","score":100,"details":"cv2 missing"}
-    blurry,dark,bright = [],[],[]
+    blurry, dark, bright = [], [], []
     with ProcessPoolExecutor(max_workers=cfg.cpu_count) as ex:
         args = [(p, cfg.blur_thr) for p in imgs]
         for p, isb, isd, isB in tqdm(
-            ex.map(_quality_stat_args, args), total=len(imgs),desc="img-quality",leave=False):
+            ex.map(_quality_stat_args, args), total=len(imgs),
+            desc="img-quality", leave=False
+        ):
             if isb: blurry.append(p)
             if isd: dark.append(p)
             if isB: bright.append(p)
     bad = len({*blurry,*dark,*bright})
-    score = 100 - bad / max(len(imgs), 1) * 100
+    score = 100 - bad/max(len(imgs),1)*100
     return {"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]}}
 
 def qc_duplicates(imgs: List[Path], cfg: QCConfig) -> Dict:
-    if fastdup and len(imgs)>50:
+    # fastdup-only path
+    if fastdup is not None and len(imgs) > 50:
         try:
-            fd = fastdup.create(input_dir=str(Path(imgs[0]).parent.parent),work_dir=str(TMP_ROOT/'fastdup'))
-            fd.run(); clusters = fd.get_clusters()
+            fd = fastdup.create(
+                input_dir=str(Path(imgs[0]).parent.parent),
+                work_dir=str(TMP_ROOT/'fastdup')
+            )
+            fd.run()
+            clusters = fd.get_clusters()
             dup = sum(len(c)-1 for c in clusters)
             return {"name":"Duplicates","score":100-dup/len(imgs)*100,
                     "details":{"groups":clusters[:50]}}
-        except:
-            pass
-    if imagehash is None:
-        return {"name":"Duplicates","score":100,"details":"deps missing"}
-    hashes = defaultdict(list)
-    with ProcessPoolExecutor(max_workers=cfg.cpu_count) as ex:
-        for h,p in tqdm(zip(ex.map(_compute_hash, imgs), imgs),total=len(imgs),desc="hashing",leave=False):
-            hashes[h].append(p)
-    groups = [g for g in hashes.values() if len(g)>1]
-    dup = sum(len(g)-1 for g in groups)
-    score = 100 - dup / max(len(imgs), 1) * 100
-    return {"name":"Duplicates","score":score,
-            "details":{"groups":[[str(p) for p in g] for g in groups[:50]]}}
+        except Exception as e:
+            return {"name":"Duplicates","score":100,
+                    "details":{"fastdup_error":str(e)}}
+    # fallback skipped
+    return {"name":"Duplicates","score":100,
+            "details":{"note":"fastdup not available or small dataset"}}
 
 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"}
     ious, mism = [], []
-    for i in range(0, len(imgs), cfg.batch_size):
+    for i in range(0,len(imgs),cfg.batch_size):
         batch = imgs[i:i+cfg.batch_size]
         results = model.predict(batch, verbose=False, half=True, dynamic=True)
-        for p,res in zip(batch, results):
+        for p,res in zip(batch,results):
             gt = parse_label_file(p.parent.parent/'labels'/f"{p.stem}.txt")
             for cls,x,y,w,h in gt:
                 best=0.0
                 for b,c,conf in zip(res.boxes.xywh.cpu().numpy(),
                                    res.boxes.cls.cpu().numpy(),
                                    res.boxes.conf.cpu().numpy()):
-                    if conf < cfg.conf_thr or int(c)!=cls: continue
-                    best = max(best, _rel_iou((x,y,w,h), tuple(b)))
+                    if conf<cfg.conf_thr or int(c)!=cls: continue
+                    best = max(best,_rel_iou((x,y,w,h),tuple(b)))
                 ious.append(best)
-                if best < cfg.iou_thr: mism.append(str(p))
+                if best<cfg.iou_thr: 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]}}
@@ -243,52 +242,53 @@ def qc_model_qa(imgs: List[Path], lbls: List[Path], cfg: QCConfig) -> Dict:
 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":"cleanlab missing"}
-    labels,preds,idxs = [],[],[]
-    for i,(img,lbl) in enumerate(zip(imgs, lbls)):
+    labels, preds, idxs = [], [], []
+    model = get_model(cfg.weights)
+    for i,(img,lbl) in enumerate(zip(imgs,lbls)):
         bs = parse_label_file(lbl) if lbl else []
         for cls,*_ in bs:
             labels.append(int(cls)); idxs.append(i)
-            # find best predicted class
-            # for simplicity, treat first pred if any
-            preds.append(int(model.predict([img])[0].boxes.cls.cpu().numpy()[0]))
+            res = model.predict([img], verbose=False)[0]
+            pred_cls = int(res.boxes.cls.cpu().numpy()[0]) if len(res.boxes)>0 else -1
+            preds.append(pred_cls)
     if not labels:
         return {"name":"Label issues","score":100,"details":"no GT"}
     labels_arr = np.array(labels)
-    # dummy prob matrix: assume one-hot perfect
-    probs = np.eye(len(set(labels_arr)))[np.searchsorted(sorted(set(labels_arr)), labels_arr)]
+    # one-hot dummy
+    uniq = sorted(set(labels_arr))
+    probs = np.eye(len(uniq))[np.searchsorted(uniq, labels_arr)]
     noise = get_noise_indices(labels=labels_arr, probabilities=probs)
-    flagged = sorted({idxs[n] for n in noise})
-    files = [str(imgs[i]) for i in flagged]
-    score = 100 - len(flagged)/len(labels)*100
-    return {"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,xa2,ya2 = x1-w1/2, y1-h1/2, x1+w1/2, y1+h1/2
-    xb1,yb1,xb2,yb2 = x2-w2/2, y2-h2/2, x2+w2/2, y2+h2/2
-    ix1,iy1,ix2,iy2 = max(xa1,xb1), max(ya1,yb1), min(xa2,xb2), min(ya2,yb2)
-    inter = max(ix2-ix1,0) * max(iy2-iy1,0)
-    union = w1*h1 + w2*h2 - inter
+    flags = sorted({idxs[n] for n in noise})
+    files = [str(imgs[i]) for i in flags]
+    score = 100 - len(flags)/len(labels)*100
+    return {"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,xa2,ya2=x1-w1/2,y1-h1/2,x1+w1/2,y1+h1/2
+    xb1,yb1,xb2,yb2=x2-w2/2,y2-h2/2,x2+w2/2,y2+h2/2
+    ix1,iy1,ix2,iy2=max(xa1,xb1),max(ya1,yb1),min(xa2,xb2),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
 
 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 URL & Download ────────────────────────────────────
 RF_RE = re.compile(r"https?://universe\.roboflow\.com/([^/]+)/([^/]+)/dataset/(\d+)")
+
 def download_rf_dataset(url: str, rf_api: Roboflow, dest: Path) -> Path:
     m = RF_RE.match(url.strip())
     if not m:
         raise ValueError(f"Bad RF URL: {url}")
     ws, proj, ver = m.groups()
     ds_dir = dest/f"{ws}_{proj}_v{ver}"
-    if ds_dir.exists():
-        return ds_dir
-    project = rf_api.workspace(ws).project(proj)
-    project.version(int(ver)).download("yolov8", location=str(ds_dir))
+    if ds_dir.exists(): return ds_dir
+    pr = rf_api.workspace(ws).project(proj)
+    pr.version(int(ver)).download("yolov8", location=str(ds_dir))
     return ds_dir
 
-# ─────────────────── Main runner & Gradio UI ─────────────────────────────
 def run_quality(root: Path, yaml_file: Path | None, weights: Path | None, cfg: QCConfig) -> Tuple[str,pd.DataFrame]:
     imgs,lbls,meta = gather_dataset(root, yaml_file)
     results = [
@@ -300,11 +300,11 @@ def run_quality(root: Path, yaml_file: Path | None, weights: Path | None, cfg: Q
         qc_label_issues(imgs,lbls,cfg),
     ]
     final = aggregate(results)
-    md = [f"## **{meta.get('name', root.name)}** — Score {final:.1f}/100"]
+    md = [f"## **{meta.get('name',root.name)}** — Score {final:.1f}/100"]
     for r in results:
         md.append(f"### {r['name']}  {r['score']:.1f}")
         md.append("<details><summary>details</summary>\n```json")
-        md.append(json.dumps(r['details'], indent=2))
+        md.append(json.dumps(r['details'],indent=2))
         md.append("```\n</details>\n")
     df = pd.DataFrame.from_dict(
         next(r for r in results if r['name']=='Class balance')['details']['class_counts'],
@@ -319,6 +319,7 @@ with gr.Blocks(title="YOLO Dataset Quality Evaluator v3") as demo:
 
 * Configurable blur, IOU & confidence thresholds
 * Cleanlab label-issue detection
+* Fastdup-only duplicates (no hashing fallback)
 * Model caching for speed
 """)
     with gr.Row():
@@ -343,7 +344,6 @@ with gr.Blocks(title="YOLO Dataset Quality Evaluator v3") as demo:
         reports, dfs = [], []
         cfg = QCConfig(blur_thr, iou_thr, conf_thr, weights.name if weights else None)
         rf = Roboflow(api_key) if api_key and Roboflow else None
-        # Roboflow batch
         if url_txt:
             for line in Path(url_txt.name).read_text().splitlines():
                 if not line.strip(): continue
@@ -353,7 +353,6 @@ with gr.Blocks(title="YOLO Dataset Quality Evaluator v3") as demo:
                     reports.append(md); dfs.append(df)
                 except Exception as e:
                     reports.append(f"### {line}\n⚠️ {e}")
-        # Manual ZIP
         if zip_file:
             tmp = Path(tempfile.mkdtemp())
             shutil.unpack_archive(zip_file.name, tmp)
@@ -361,7 +360,6 @@ with gr.Blocks(title="YOLO Dataset Quality Evaluator v3") as demo:
                                  Path(weights.name) if weights else None, cfg)
             reports.append(md); dfs.append(df)
             shutil.rmtree(tmp, ignore_errors=True)
-        # Server path
         if server_path:
             ds = Path(server_path)
             md, df = run_quality(ds, Path(yaml_file.name) if yaml_file else None,