| """Step 1b: DINOv2 embeddings of the cropped fundus for near-duplicate detection. |
| |
| 64-bit perceptual hashes are too coarse for fundus photographs (every image is an orange disc with a darker |
| macula), so near-duplicates are found with self-supervised embeddings instead, with a threshold calibrated on |
| synthetic copies (see `calibrate`). |
| python -m fsbench.embed --raw data/raw --bench data/bench [--model facebook/dinov2-small] |
| Writes embeddings.npy (float16, L2-normalised, row order = manifest.csv) and embed_calibration.csv |
| """ |
| import argparse |
| import io |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
| from PIL import Image |
| from transformers import AutoImageProcessor, AutoModel |
|
|
| from .hashing import crop_fundus |
|
|
| Image.MAX_IMAGE_PIXELS = None |
|
|
|
|
| class _DS(torch.utils.data.Dataset): |
| def __init__(self, paths, proc, transform=None): |
| self.paths, self.proc, self.transform = paths, proc, transform |
|
|
| def __len__(self): |
| return len(self.paths) |
|
|
| def __getitem__(self, i): |
| try: |
| im = crop_fundus(Image.open(self.paths[i]).convert("RGB")) |
| if self.transform: |
| im = self.transform(im, i) |
| except Exception: |
| im = Image.new("RGB", (224, 224)) |
| return self.proc(images=im, return_tensors="pt")["pixel_values"][0] |
|
|
|
|
| def embed(paths, model, proc, device, transform=None, bs=64): |
| dl = torch.utils.data.DataLoader(_DS(paths, proc, transform), batch_size=bs, num_workers=6) |
| out = [] |
| with torch.no_grad(): |
| for x in dl: |
| h = model(pixel_values=x.to(device)).pooler_output |
| out.append(torch.nn.functional.normalize(h, dim=1).cpu().numpy().astype(np.float16)) |
| return np.concatenate(out) |
|
|
|
|
| def _copy_transform(im, i): |
| """Typical re-distribution edits: rescale, JPEG recompression, small crop, brightness change.""" |
| rng = np.random.default_rng(i) |
| s = rng.uniform(0.35, 0.8) |
| im = im.resize((max(32, int(im.width * s)), max(32, int(im.height * s)))) |
| c = rng.uniform(0, 0.04) |
| im = im.crop((int(im.width * c), int(im.height * c), int(im.width * (1 - c)), int(im.height * (1 - c)))) |
| buf = io.BytesIO() |
| im.save(buf, "JPEG", quality=int(rng.integers(60, 90))) |
| im = Image.open(io.BytesIO(buf.getvalue())).convert("RGB") |
| return Image.eval(im, lambda v: min(255, int(v * rng.uniform(0.9, 1.1)))) |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--raw", required=True) |
| ap.add_argument("--bench", required=True) |
| ap.add_argument("--model", default="facebook/dinov2-small") |
| ap.add_argument("--n-calib", type=int, default=600) |
| a = ap.parse_args(argv) |
| bench = Path(a.bench) |
| m = pd.read_csv(bench / "manifest.csv", dtype=str, keep_default_na=False) |
| device = "mps" if torch.backends.mps.is_available() else ("cuda" if torch.cuda.is_available() else "cpu") |
| proc = AutoImageProcessor.from_pretrained(a.model) |
| model = AutoModel.from_pretrained(a.model).to(device).eval() |
| paths = [str(Path(a.raw) / s / p) for s, p in zip(m.source, m.rel_path)] |
| ok = (m.sha256 != "").to_numpy() |
| E = np.zeros((len(m), model.config.hidden_size), np.float16) |
| E[ok] = embed([p for p, k in zip(paths, ok) if k], model, proc, device) |
| np.save(bench / "embeddings.npy", E) |
|
|
| |
| rng = np.random.default_rng(0) |
| idx = rng.choice(np.flatnonzero(ok), size=min(a.n_calib, ok.sum()), replace=False) |
| C = embed([paths[i] for i in idx], model, proc, device, transform=_copy_transform) |
| copy_cos = (C.astype(np.float32) * E[idx].astype(np.float32)).sum(1) |
| Ef = E.astype(np.float32) |
| nn_other = [] |
| for i in idx: |
| same_src = (m.source == m.source.iloc[i]).to_numpy() & ok |
| other = same_src & ~((m.patient_id == m.patient_id.iloc[i]).to_numpy() & (m.patient_id.iloc[i] != "")) |
| other[i] = False |
| nn_other.append(float((Ef[other] @ Ef[i]).max()) if other.any() else np.nan) |
| cal = pd.DataFrame({"image_id": m.image_id.to_numpy()[idx], "source": m.source.to_numpy()[idx], |
| "cos_edited_copy": copy_cos, "cos_nearest_other_image": nn_other}) |
| cal.to_csv(bench / "embed_calibration.csv", index=False) |
| q = cal[["cos_edited_copy", "cos_nearest_other_image"]].quantile([0.01, 0.05, 0.5, 0.95, 0.99]) |
| print(q.to_string()) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
