Datasets:
File size: 7,480 Bytes
53de216 70f9003 53de216 70f9003 53de216 70f9003 53de216 0deaed4 53de216 0deaed4 53de216 0deaed4 53de216 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | """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"] # canonical class order; the release uses those present in train
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()
|