| """Minimal ERM baseline for FundusShift: ImageNet ResNet-50 fine-tuned on train, checkpoint chosen on validation |
| (balanced accuracy), logits written for every split -> baselines/evaluate.py. |
| |
| python baselines/train_baseline.py --out runs/resnet50 [--epochs 10 --size 384 --bs 32 --limit 0] |
| python baselines/train_baseline.py --out runs/resnet50 --splits-csv metadata/splits_final.csv --image-root images/ |
| Class imbalance and source imbalance are handled with a sampler weighting each (source, class) cell equally, |
| as in the benchmark protocol (pooled training otherwise lets the largest source dominate). |
| """ |
| import argparse |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
| import torchvision.transforms.v2 as T |
| from PIL import Image |
| from sklearn.metrics import balanced_accuracy_score |
| from torchvision.models import ConvNeXt_Tiny_Weights, ResNet50_Weights, convnext_tiny, resnet50 |
|
|
| CANON = ["N", "D", "G", "A", "M"] |
| CLASSES = list(CANON) |
|
|
|
|
| def transforms(size, train): |
| norm = T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) |
| if train: |
| return T.Compose([T.RandomResizedCrop(size, scale=(0.7, 1.0), ratio=(0.9, 1.1)), T.RandomHorizontalFlip(), |
| T.RandomRotation(15), T.ColorJitter(0.2, 0.2, 0.1, 0.02), T.ToImage(), |
| T.ToDtype(torch.float32, scale=True), norm]) |
| return T.Compose([T.Resize((size, size)), T.ToImage(), T.ToDtype(torch.float32, scale=True), norm]) |
|
|
|
|
| class LocalSplit(torch.utils.data.Dataset): |
| """Rows of splits_final.csv + processed images: <image_root>/<source>/<image_id>.jpg""" |
|
|
| def __init__(self, df, root, tf): |
| self.df, self.root, self.tf = df.reset_index(drop=True), Path(root), tf |
|
|
| def __len__(self): |
| return len(self.df) |
|
|
| def __getitem__(self, i): |
| r = self.df.iloc[i] |
| im = Image.open(self.root / r.source / f"{r.image_id}.jpg").convert("RGB") |
| return {"x": self.tf(im), "y": int(r.y), "image_id": r.image_id} |
|
|
|
|
| class HubSplit(torch.utils.data.Dataset): |
| def __init__(self, ds, tf): |
| self.ds, self.tf = ds, tf |
|
|
| def __len__(self): |
| return len(self.ds) |
|
|
| def __getitem__(self, i): |
| r = self.ds[i] |
| return {"x": self.tf(r["image"].convert("RGB")), "y": r["label"], "image_id": r["image_id"]} |
|
|
|
|
| def load_splits(a): |
| """{split: (meta DataFrame with image_id/source/y, torch Dataset factory)} from the Hub or local files.""" |
| if a.splits_csv: |
| d = pd.read_csv(a.splits_csv, dtype=str, keep_default_na=False) |
| d["split"] = d.split.replace({"val": "validation", "cal": "calibration"}) |
| CLASSES[:] = [c for c in CANON if c in set(d.label[d.split == "train"])] |
| d["y"] = [CLASSES.index(l) if l in CLASSES else -1 for l in d.label] |
| out = {} |
| for s in ["train", "validation", "calibration", "test", "test_ood", "test_openset"]: |
| sub = d[d.split == s] |
| if a.limit: |
| sub = sub.sample(min(a.limit, len(sub)), random_state=0) |
| out[s] = (sub[["image_id", "source", "y"]].reset_index(drop=True), |
| lambda tf, sub=sub: LocalSplit(sub, a.image_root, tf)) |
| return out |
| from datasets import load_dataset |
| ds = load_dataset(a.repo) |
| CLASSES[:] = ds["train"].features["label"].names |
| out = {} |
| for s, v in ds.items(): |
| if a.limit: |
| v = v.shuffle(seed=0).select(range(min(a.limit, len(v)))) |
| meta = pd.DataFrame({"image_id": v["image_id"], "source": v["source"], "y": v["label"]}) |
| out[s] = (meta, lambda tf, v=v: HubSplit(v, tf)) |
| return out |
|
|
|
|
| def collate(b): |
| return torch.stack([r["x"] for r in b]), torch.tensor([r["y"] for r in b]), [r["image_id"] for r in b] |
|
|
|
|
| def loader(split, size, train, bs, workers): |
| meta, make = split |
| ds = make(transforms(size, train)) |
| if train: |
| cell = pd.Series(list(zip(meta.source, meta.y))) |
| w = 1.0 / cell.map(cell.value_counts()).to_numpy() |
| sampler = torch.utils.data.WeightedRandomSampler(w, num_samples=len(w), replacement=True) |
| return torch.utils.data.DataLoader(ds, bs, sampler=sampler, num_workers=workers, collate_fn=collate) |
| return torch.utils.data.DataLoader(ds, bs, shuffle=False, num_workers=workers, collate_fn=collate) |
|
|
|
|
| @torch.no_grad() |
| def predict(model, dl, device): |
| model.eval() |
| ids, logits, ys = [], [], [] |
| for x, y, i in dl: |
| logits.append(model(x.to(device)).float().cpu()) |
| ys.append(y) |
| ids += i |
| return ids, torch.cat(logits).numpy(), torch.cat(ys).numpy() |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--repo", default="le-dang1haha/FundusShift") |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--epochs", type=int, default=10) |
| ap.add_argument("--size", type=int, default=384) |
| ap.add_argument("--bs", type=int, default=32) |
| ap.add_argument("--lr", type=float, default=3e-4) |
| ap.add_argument("--workers", type=int, default=6) |
| ap.add_argument("--limit", type=int, default=0, help="debug: use only N images per split") |
| ap.add_argument("--splits-csv", help="local mode: metadata/splits_final.csv instead of the Hub") |
| ap.add_argument("--image-root", help="local mode: folder with <source>/<image_id>.jpg") |
| ap.add_argument("--arch", default="resnet50", choices=["resnet50", "convnext_tiny"]) |
| ap.add_argument("--seed", type=int, default=0) |
| a = ap.parse_args(argv) |
| out = Path(a.out) |
| out.mkdir(parents=True, exist_ok=True) |
| device = "cuda" if torch.cuda.is_available() else ("mps" if torch.backends.mps.is_available() else "cpu") |
| torch.manual_seed(a.seed) |
| np.random.seed(a.seed) |
| ds = load_splits(a) |
| if a.arch == "resnet50": |
| model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V2) |
| model.fc = torch.nn.Linear(model.fc.in_features, len(CLASSES)) |
| else: |
| model = convnext_tiny(weights=ConvNeXt_Tiny_Weights.IMAGENET1K_V1) |
| model.classifier[2] = torch.nn.Linear(model.classifier[2].in_features, len(CLASSES)) |
| model.to(device) |
| opt = torch.optim.AdamW(model.parameters(), lr=a.lr, weight_decay=1e-4) |
| tr = loader(ds["train"], a.size, True, a.bs, a.workers) |
| va = loader(ds["validation"], a.size, False, a.bs, a.workers) |
| sched = torch.optim.lr_scheduler.OneCycleLR(opt, a.lr, total_steps=a.epochs * len(tr)) |
| best = -1.0 |
| for ep in range(a.epochs): |
| model.train() |
| for x, y, _ in tr: |
| loss = torch.nn.functional.cross_entropy(model(x.to(device)), y.to(device), label_smoothing=0.05) |
| opt.zero_grad() |
| loss.backward() |
| opt.step() |
| sched.step() |
| _, lg, y = predict(model, va, device) |
| bacc = balanced_accuracy_score(y, lg.argmax(1)) |
| print(f"epoch {ep + 1}: val balanced acc {bacc:.4f}") |
| if bacc > best: |
| best = bacc |
| torch.save(model.state_dict(), out / "best.pt") |
| model.load_state_dict(torch.load(out / "best.pt", map_location=device)) |
| for split in ds: |
| ids, lg, _ = predict(model, loader(ds[split], a.size, False, a.bs, a.workers), device) |
| df = pd.DataFrame(lg, columns=[f"logit_{c}" for c in CLASSES]) |
| df.insert(0, "image_id", ids) |
| df.to_csv(out / f"{split}.csv", index=False) |
| print(f"best val balanced acc {best:.4f}; logits in {out}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
