code/run_all.py

#!/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()