Datasets:
File size: 5,409 Bytes
3c366de | 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 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Orchestrate the 21 runs (7 datasets x 3 models) across 8 GPUs.
- RetFound : official RETFound/main_finetune.py (ViT-L, RETFound_mae_natureCFP weights)
- ResNet : train_cnn_vit.py resnet50 (ImageNet pretrained)
- ViT : train_cnn_vit.py vit_base_patch16_224 (ImageNet pretrained)
Each job = "train && evaluate.py"; pinned to one free GPU via CUDA_VISIBLE_DEVICES.
At most len(GPUS) jobs run concurrently. Use --dry_run to print the plan.
"""
import os, sys, time, json, argparse, subprocess
from itertools import product
PROJ = "/mnt/tidal-alsh-share2/dataset/qinshengqian/research/c3/GPT-Image"
DSROOT = f"{PROJ}/Dataset"
CODE = f"{PROJ}/Code"
RETF = f"{CODE}/RETFound"
CFP = f"{PROJ}/weights/pretrained/RETFound_mae_natureCFP.pth"
RESULTS = f"{PROJ}/results"
PY = "/root/miniconda3/envs/retfound/bin/python"
TORCHRUN = "/root/miniconda3/envs/retfound/bin/torchrun"
GPUS = [0, 1, 2, 3, 4, 5, 6, 7]
# key : (rel_path, nb_classes, epochs, class_names)
DATASETS = {
"mmac": ("Myopia/Classification_of_Myopic_Maculopathy", 5, 50, "g0,g1,g2,g3,g4"),
"adam": ("AMD/adamdataset", 2, 50, "NonAMD,AMD"),
"airogs": ("Glaucoma/eyepacs-airogs-light", 2, 30, "NRG,RG"),
"papila": ("Glaucoma/papila-retinal-fundus-images", 2, 50, "healthy,glaucoma"),
"idrid": ("DR/idrid-dataset", 5, 50, "g0,g1,g2,g3,g4"),
"aptos": ("DR/aptos2019", 5, 30, "g0,g1,g2,g3,g4"),
"deepdrid": ("DR/deepdrid", 5, 50, "g0,g1,g2,g3,g4"),
}
MODELS = ["retfound", "resnet", "vit"]
def train_cmd(model, dsk, port):
rel, nc, ep, _ = DATASETS[dsk]
dpath = f"{DSROOT}/{rel}"
odir = f"{RESULTS}/{dsk}"
if model == "retfound":
return (f"cd {RETF} && {TORCHRUN} --nproc_per_node=1 --master_port={port} "
f"main_finetune.py --model RETFound_mae --model_arch retfound_mae "
f"--finetune {CFP} --savemodel --global_pool --batch_size 32 --world_size 1 "
f"--epochs {ep} --nb_classes {nc} --data_path {dpath} --input_size 224 "
f"--task retfound --output_dir {odir} --adaptation finetune")
timm_name = "resnet50" if model == "resnet" else "vit_base_patch16_224"
# ViT-specific fine-tuning recipe (lower lr + layer-wise lr decay + drop-path + label smoothing)
extra = ("" if model == "resnet" else
" --lr 1e-4 --layer_decay 0.65 --drop_path 0.1 --label_smoothing 0.1 --warmup_epochs 5")
return (f"cd {CODE} && {PY} train_cnn_vit.py --data_path {dpath} --nb_classes {nc} "
f"--model {timm_name} --input_size 224 --batch_size 64 --epochs {ep} "
f"--output_dir {odir} --task {model}{extra}")
def job_cmd(model, dsk, port):
_, _, _, names = DATASETS[dsk]
run_dir = f"{RESULTS}/{dsk}/{model}"
return (f"{train_cmd(model, dsk, port)} && "
f"{PY} {CODE}/evaluate.py --run_dir {run_dir} --class_names {names}")
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--dry_run", action="store_true")
ap.add_argument("--only_models", default="") # e.g. resnet,vit
ap.add_argument("--only_datasets", default="") # e.g. idrid,adam
args = ap.parse_args()
models = args.only_models.split(",") if args.only_models else MODELS
dsets = args.only_datasets.split(",") if args.only_datasets else list(DATASETS)
jobs = []
for i, (dsk, model) in enumerate(product(dsets, models)):
run_dir = f"{RESULTS}/{dsk}/{model}"
os.makedirs(run_dir, exist_ok=True)
jobs.append({"name": f"{dsk}/{model}", "dsk": dsk, "model": model,
"port": 29500 + i, "run_dir": run_dir,
"cmd": job_cmd(model, dsk, 29500 + i)})
print(f"=== {len(jobs)} jobs over {len(GPUS)} GPUs ===")
for j in jobs:
print(f" {j['name']}")
if args.dry_run:
print("\n--- sample command ---\n" + jobs[0]["cmd"])
return
free = list(GPUS)
running = {} # pid -> (job, gpu, fh)
pending = list(jobs)
done, failed = [], []
while pending or running:
while pending and free:
g = free.pop(0)
j = pending.pop(0)
env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(g))
fh = open(os.path.join(j["run_dir"], "train.log"), "w")
p = subprocess.Popen(["bash", "-lc", j["cmd"]], env=env, stdout=fh,
stderr=subprocess.STDOUT)
running[p.pid] = (j, g, fh, p)
print(f"[launch] GPU{g} {j['name']} (pid {p.pid}) [{len(done)+len(failed)}/{len(jobs)} done]")
time.sleep(10)
for pid in list(running):
j, g, fh, p = running[pid]
rc = p.poll()
if rc is None:
continue
fh.close(); free.append(g); del running[pid]
ok = (rc == 0 and os.path.isfile(os.path.join(j["run_dir"], "metrics.json")))
(done if ok else failed).append(j["name"])
print(f"[{'done' if ok else 'FAIL'}] GPU{g} {j['name']} rc={rc} "
f"[{len(done)+len(failed)}/{len(jobs)}]")
print(f"\n=== finished: {len(done)} ok, {len(failed)} failed ===")
if failed:
print("FAILED:", failed)
if __name__ == "__main__":
main()
|