add src

.gitignore

@@ -0,0 +1 @@
+.idea

app.py

@@ -0,0 +1,465 @@
+# app.py
+
+import argparse
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+import torch
+import torch.nn.functional as F
+
+from augmentations import get_val_transforms
+from model import DeepSeeNet
+
+
+ID_TO_LABEL = {
+    0: "No DR",
+    1: "Mild NPDR",
+    2: "Moderate NPDR",
+    3: "Severe NPDR",
+    4: "PDR",
+}
+
+
+BUCKET_MODE_DESCRIPTIONS = {
+    "severity": "5-class DR severity",
+    "referral": "Non-referable vs referable DR",
+    "any_dr": "No DR vs any DR",
+    "stage": "No DR vs NPDR vs PDR",
+    "high_risk": "Non-severe vs severe/PDR",
+}
+
+
+class AlbumentationsTransform:
+    def __init__(self, transform):
+        self.transform = transform
+
+    def __call__(self, image):
+        return self.transform(image=np.asarray(image))["image"]
+
+
+def unwrap_logits(output):
+    if isinstance(output, (tuple, list)):
+        return output[0]
+    return output
+
+
+def find_fold_checkpoints(checkpoint_dir, checkpoint_name="best_model_only.pt"):
+    checkpoint_dir = Path(checkpoint_dir)
+
+    if not checkpoint_dir.exists():
+        raise FileNotFoundError(f"Checkpoint directory not found: {checkpoint_dir}")
+
+    paths = sorted(checkpoint_dir.glob(f"*_fold*/{checkpoint_name}"))
+
+    if len(paths) == 0:
+        # fallback: allow directly passing a folder containing checkpoints
+        paths = sorted(checkpoint_dir.glob(f"**/{checkpoint_name}"))
+
+    if len(paths) == 0:
+        raise FileNotFoundError(
+            f"No fold checkpoints named '{checkpoint_name}' found under {checkpoint_dir}"
+        )
+
+    return paths
+
+
+def load_single_model(checkpoint_path, backbone, image_size, device):
+    checkpoint_path = Path(checkpoint_path)
+    ckpt = torch.load(checkpoint_path, map_location=device)
+
+    saved_args = ckpt.get("args", {})
+    backbone = saved_args.get("backbone", backbone)
+    image_size = int(saved_args.get("image_size", image_size))
+
+    model = DeepSeeNet(
+        n_classes=5,
+        backbone=backbone,
+        pretrained=False,
+        freeze_backbone=False,
+    )
+
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.to(device)
+    model.eval()
+
+    return model, backbone, image_size, ckpt
+
+
+def load_ensemble(checkpoint_dir, checkpoint_name, backbone, image_size, device):
+    checkpoint_paths = find_fold_checkpoints(
+        checkpoint_dir=checkpoint_dir,
+        checkpoint_name=checkpoint_name,
+    )
+
+    models = []
+    ckpts = []
+    resolved_backbone = backbone
+    resolved_image_size = image_size
+
+    for path in checkpoint_paths:
+        model, resolved_backbone, resolved_image_size, ckpt = load_single_model(
+            checkpoint_path=path,
+            backbone=resolved_backbone,
+            image_size=resolved_image_size,
+            device=device,
+        )
+
+        models.append(model)
+        ckpts.append(ckpt)
+
+    transform = AlbumentationsTransform(get_val_transforms(resolved_image_size))
+
+    return models, transform, resolved_backbone, resolved_image_size, checkpoint_paths, ckpts
+
+
+def get_grouped_probs(probs, mode):
+    p0, p1, p2, p3, p4 = probs
+
+    if mode == "severity":
+        return {
+            "No DR": float(p0),
+            "Mild NPDR": float(p1),
+            "Moderate NPDR": float(p2),
+            "Severe NPDR": float(p3),
+            "PDR": float(p4),
+        }
+
+    if mode == "referral":
+        return {
+            "Non-referable DR": float(p0 + p1),
+            "Referable DR": float(p2 + p3 + p4),
+        }
+
+    if mode == "any_dr":
+        return {
+            "No DR": float(p0),
+            "Any DR": float(p1 + p2 + p3 + p4),
+        }
+
+    if mode == "stage":
+        return {
+            "No DR": float(p0),
+            "NPDR": float(p1 + p2 + p3),
+            "PDR": float(p4),
+        }
+
+    if mode == "high_risk":
+        return {
+            "Non-severe / non-PDR": float(p0 + p1 + p2),
+            "Severe NPDR or PDR": float(p3 + p4),
+        }
+
+    raise ValueError(f"Unknown bucket mode: {mode}")
+
+
+def grouped_probs_to_fixed_dataframe(prob_dict, max_rows=5):
+    rows = [
+        {
+            "label": label,
+            "probability": f"{prob:.4f}",
+        }
+        for label, prob in prob_dict.items()
+    ]
+
+    rows = sorted(rows, key=lambda x: float(x["probability"]), reverse=True)
+
+    while len(rows) < max_rows:
+        rows.append({"label": "", "probability": ""})
+
+    return pd.DataFrame(rows[:max_rows], columns=["label", "probability"])
+
+
+def fold_probs_to_dataframe(fold_probs, checkpoint_paths):
+    rows = []
+
+    for i, probs in enumerate(fold_probs):
+        pred_grade = int(np.argmax(probs))
+        pred_label = ID_TO_LABEL[pred_grade]
+
+        rows.append(
+            {
+                "fold": Path(checkpoint_paths[i]).parent.name,
+                "prediction": pred_label,
+                "probability": f"{float(probs[pred_grade]):.4f}",
+                "p0_no_dr": f"{float(probs[0]):.4f}",
+                "p1_mild": f"{float(probs[1]):.4f}",
+                "p2_moderate": f"{float(probs[2]):.4f}",
+                "p3_severe": f"{float(probs[3]):.4f}",
+                "p4_pdr": f"{float(probs[4]):.4f}",
+            }
+        )
+
+    return pd.DataFrame(rows)
+
+
+def ensemble_predict(models, x):
+    fold_probs = []
+
+    with torch.no_grad():
+        for model in models:
+            logits = unwrap_logits(model(x))
+            probs = F.softmax(logits, dim=1)[0].detach().cpu().numpy()
+            fold_probs.append(probs)
+
+    fold_probs = np.stack(fold_probs, axis=0)
+    ensemble_probs = fold_probs.mean(axis=0)
+
+    return ensemble_probs, fold_probs
+
+
+def make_prediction_fn(models, transform, checkpoint_paths, device):
+    def predict(image, bucket_mode):
+        empty_df = pd.DataFrame(
+            [{"label": "", "probability": ""} for _ in range(5)],
+            columns=["label", "probability"],
+        )
+
+        empty_fold_df = pd.DataFrame(
+            columns=[
+                "fold",
+                "prediction",
+                "probability",
+                "p0_no_dr",
+                "p1_mild",
+                "p2_moderate",
+                "p3_severe",
+                "p4_pdr",
+            ]
+        )
+
+        if image is None:
+            return (
+                None,
+                empty_df,
+                empty_fold_df,
+                "Upload a fundus image to run ensemble inference.",
+            )
+
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+
+        image = image.convert("RGB")
+        x = transform(image).unsqueeze(0).to(device)
+
+        probs, fold_probs = ensemble_predict(models, x)
+
+        pred_grade = int(np.argmax(probs))
+        pred_label = ID_TO_LABEL[pred_grade]
+        pred_prob = float(probs[pred_grade])
+
+        raw_probs = {
+            ID_TO_LABEL[i]: float(probs[i])
+            for i in range(5)
+        }
+
+        grouped_probs = get_grouped_probs(probs, bucket_mode)
+        bucket_label = max(grouped_probs, key=grouped_probs.get)
+        bucket_prob = grouped_probs[bucket_label]
+        bucket_df = grouped_probs_to_fixed_dataframe(grouped_probs, max_rows=5)
+
+        fold_df = fold_probs_to_dataframe(fold_probs, checkpoint_paths)
+
+        fold_preds = [ID_TO_LABEL[int(np.argmax(p))] for p in fold_probs]
+        agreement = fold_preds.count(pred_label) / len(fold_preds)
+
+        summary = (
+            f"Ensemble prediction: {pred_label} "
+            f"(grade {pred_grade}, probability {pred_prob:.3f})\n\n"
+            f"Probability grouping: {BUCKET_MODE_DESCRIPTIONS[bucket_mode]}\n"
+            f"Grouped result: {bucket_label} "
+            f"(probability {bucket_prob:.3f})\n\n"
+            f"Fold agreement with ensemble class: {agreement:.1%} "
+            f"({fold_preds.count(pred_label)}/{len(fold_preds)} folds)"
+        )
+
+        return raw_probs, bucket_df, fold_df, summary
+
+    return predict
+
+
+def make_app(checkpoint_dir, checkpoint_name, backbone, image_size, device):
+    (
+        models,
+        transform,
+        backbone,
+        image_size,
+        checkpoint_paths,
+        ckpts,
+    ) = load_ensemble(
+        checkpoint_dir=checkpoint_dir,
+        checkpoint_name=checkpoint_name,
+        backbone=backbone,
+        image_size=image_size,
+        device=device,
+    )
+
+    predict_fn = make_prediction_fn(
+        models=models,
+        transform=transform,
+        checkpoint_paths=checkpoint_paths,
+        device=device,
+    )
+
+    fold_names = [p.parent.name for p in checkpoint_paths]
+
+    best_metrics = [
+        ckpt.get("best_metric", None)
+        for ckpt in ckpts
+    ]
+
+    model_info = (
+        f"Backbone: `{backbone}`  |  "
+        f"Input: `{image_size}×{image_size}`  |  "
+        f"Folds loaded: `{len(models)}`  |  "
+        f"Device: `{device}`"
+    )
+
+    # fold_info = "Loaded checkpoints: " + ", ".join(fold_names)
+    #
+    # if any(m is not None for m in best_metrics):
+    #     metric_info = "Best metrics: " + ", ".join(
+    #         "NA" if m is None else f"{float(m):.4f}"
+    #         for m in best_metrics
+    #     )
+    # else:
+    #     metric_info = ""
+
+    with gr.Blocks(title="EyePACS DR Ensemble Classifier") as demo:
+        gr.Markdown("# EyePACS DR Ensemble Classifier")
+        gr.Markdown(model_info)
+        # gr.Markdown(fold_info)
+        # if metric_info:
+        #     gr.Markdown(metric_info)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                image = gr.Image(
+                    type="pil",
+                    label="Fundus image",
+                )
+
+                bucket_mode = gr.Dropdown(
+                    choices=[
+                        "severity",
+                        "referral",
+                        "any_dr",
+                        "stage",
+                        "high_risk",
+                    ],
+                    value="referral",
+                    label="Probability grouping",
+                )
+
+                run_btn = gr.Button("Run inference", variant="primary")
+
+            with gr.Column(scale=1):
+                raw_probs = gr.Label(
+                    num_top_classes=5,
+                    label="Ensemble raw 5-class probabilities",
+                )
+
+                bucket_table = gr.Dataframe(
+                    label="Grouped probabilities",
+                    headers=["label", "probability"],
+                    row_count=(5, "fixed"),
+                    col_count=(2, "fixed"),
+                    interactive=False,
+                    wrap=True,
+                )
+
+                with gr.Accordion("Per-fold predictions", open=False):
+                    fold_table = gr.Dataframe(
+                        label="Per-fold probabilities",
+                        interactive=False,
+                        wrap=True,
+                    )
+
+                summary = gr.Textbox(
+                    label="Summary",
+                    lines=7,
+                    interactive=False,
+                )
+
+        inputs = [image, bucket_mode]
+        outputs = [raw_probs, bucket_table, fold_table, summary]
+
+        run_btn.click(
+            fn=predict_fn,
+            inputs=inputs,
+            outputs=outputs,
+        )
+
+        image.change(
+            fn=predict_fn,
+            inputs=inputs,
+            outputs=outputs,
+        )
+
+        bucket_mode.change(
+            fn=predict_fn,
+            inputs=inputs,
+            outputs=outputs,
+        )
+
+    return demo
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="EyePACS DR Gradio ensemble inference app."
+    )
+
+    parser.add_argument(
+        "--checkpoint-dir",
+        default="runs/eyepacs_dr",
+        help="Folder containing fold checkpoint folders.",
+    )
+    parser.add_argument(
+        "--checkpoint-name",
+        default="best_model_only.pt",
+        help="Checkpoint filename inside each fold folder.",
+    )
+    parser.add_argument(
+        "--backbone",
+        default="inception_v3",
+        help="Fallback backbone if checkpoint args are unavailable.",
+    )
+    parser.add_argument(
+        "--image-size",
+        type=int,
+        default=1024,
+        help="Fallback image size if checkpoint args are unavailable.",
+    )
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=7860)
+    parser.add_argument("--share", action="store_true")
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    demo = make_app(
+        checkpoint_dir=args.checkpoint_dir,
+        checkpoint_name=args.checkpoint_name,
+        backbone=args.backbone,
+        image_size=args.image_size,
+        device=device,
+    )
+
+    demo.launch(
+        # server_name=args.host,
+        # server_port=args.port,
+        # share=args.share,
+    )
+
+
+if __name__ == "__main__":
+    main()

augmentations.py

@@ -0,0 +1,85 @@
+"""
+augmentations.py
+
+Simple camera-style augmentations for color fundus photography (CFP)
+classification.
+
+Expected input:
+    RGB NumPy image, shape (H, W, 3)
+
+Dependencies:
+    pip install albumentations opencv-python
+"""
+
+import cv2
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def get_train_transforms(
+    image_size=1024,
+    mean=IMAGENET_MEAN,
+    std=IMAGENET_STD,
+):
+    return A.Compose([
+        A.Resize(image_size, image_size),
+
+        # Geometry is safe
+        A.HorizontalFlip(p=0.5),
+
+        A.ShiftScaleRotate(
+            shift_limit=0.02,
+            scale_limit=0.03,   # slightly reduced
+            rotate_limit=5,     # slightly reduced
+            border_mode=0,
+            value=0,
+            p=0.3,
+        ),
+
+        # MUCH weaker photometric changes
+        A.RandomBrightnessContrast(
+            brightness_limit=0.08,   # ↓ from 0.15
+            contrast_limit=0.08,
+            p=0.3,
+        ),
+
+        # Remove or reduce gamma
+        A.RandomGamma(
+            gamma_limit=(95, 105),   # very mild
+            p=0.2,
+        ),
+
+        # Remove hue shift entirely (important)
+        # Hue shifts are not realistic for fundus physiology
+        # -> comment this out or reduce heavily
+        # A.HueSaturationValue(...)
+
+        # Keep mild quality perturbation
+        A.OneOf([
+            A.GaussianBlur(blur_limit=(3, 5)),
+            A.Downscale(scale_min=0.85, scale_max=0.95, interpolation=cv2.INTER_LINEAR),
+            A.ImageCompression(quality_lower=80, quality_upper=100),
+        ], p=0.15),
+
+        A.Normalize(mean=mean, std=std),
+        ToTensorV2(),
+    ])
+
+
+def get_val_transforms(
+    image_size=1024,
+    mean=IMAGENET_MEAN,
+    std=IMAGENET_STD,
+):
+    """
+    Validation/test transforms.
+    """
+    return A.Compose([
+        A.Resize(image_size, image_size),
+        A.Normalize(mean=mean, std=std),
+        ToTensorV2(),
+    ])

dataloader.py

@@ -0,0 +1,356 @@
+from pathlib import Path
+from typing import Optional, Sequence
+
+import pandas as pd
+from PIL import Image
+
+import torch
+from torch.utils.data import Dataset
+from sklearn.model_selection import StratifiedGroupKFold
+
+
+class EyePACSDataset(Dataset):
+    """
+    EyePACS diabetic retinopathy dataset.
+
+    Expected structure:
+        root/
+        ├── trainLabels.csv
+        ├── testLabels.csv
+        ├── train/
+        │   ├── xxx_left.jpeg
+        │   └── xxx_right.jpeg
+        └── test/
+            ├── xxx_left.jpeg
+            └── xxx_right.jpeg
+
+    Supported splits:
+        train:
+            Uses trainLabels.csv only.
+            Applies fold CV.
+            Keeps samples where fold != selected fold.
+
+        val:
+            Uses trainLabels.csv only.
+            Applies fold CV.
+            Keeps samples where fold == selected fold.
+
+        test:
+            Uses testLabels.csv only.
+            Uses original test/ image folder.
+            No fold filtering.
+
+        all:
+            Uses trainLabels.csv + testLabels.csv.
+            Applies fold CV over the combined labeled pool.
+            If fold is not None:
+                keeps samples where fold != selected fold by default if all_mode="train"
+                keeps samples where fold == selected fold if all_mode="val"
+            If fold is None:
+                keeps all combined labeled samples.
+
+    Args:
+        root:
+            EyePACS root directory.
+
+        split:
+            One of {"train", "val", "test", "all"}.
+
+        transform:
+            Optional image transform.
+
+        seed:
+            Random seed for fold assignment.
+
+        fold:
+            Selected fold index. Required for split="train" and split="val".
+            Optional for split="all". Ignored for split="test".
+
+        n_folds:
+            Number of folds.
+
+        all_mode:
+            Only used when split="all" and fold is not None.
+            Options:
+                "train": keep fold != selected fold
+                "val":   keep fold == selected fold
+                "all":   keep all folds
+
+        return_path:
+            If True, return metadata dictionary.
+
+        image_exts:
+            File extensions to try.
+    """
+
+    def __init__(
+        self,
+        root,
+        split: str = "train",
+        transform=None,
+        seed: int = 42,
+        fold: Optional[int] = 0,
+        n_folds: int = 5,
+        all_mode: str = "all",
+        return_path: bool = False,
+        image_exts: Sequence[str] = (".jpeg", ".jpg", ".png"),
+    ):
+        self.root = Path(root)
+        self.split = split
+        self.transform = transform
+        self.seed = seed
+        self.fold = fold
+        self.n_folds = n_folds
+        self.all_mode = all_mode
+        self.return_path = return_path
+        self.image_exts = tuple(image_exts)
+
+        if split not in {"train", "val", "test", "all"}:
+            raise ValueError(
+                f"split must be one of {{'train', 'val', 'test', 'all'}}, got {split}"
+            )
+
+        if all_mode not in {"train", "val", "all"}:
+            raise ValueError(
+                f"all_mode must be one of {{'train', 'val', 'all'}}, got {all_mode}"
+            )
+
+        if split in {"train", "val"} and fold is None:
+            raise ValueError(f"fold must be provided for split='{split}'")
+
+        if fold is not None and not (0 <= fold < n_folds):
+            raise ValueError(f"fold must be in [0, {n_folds - 1}], got {fold}")
+
+        if split == "train":
+            df = self._load_train_dataframe()
+            df = self._assign_folds(df)
+            df = df[df["fold"] != fold].reset_index(drop=True)
+
+        elif split == "val":
+            df = self._load_train_dataframe()
+            df = self._assign_folds(df)
+            df = df[df["fold"] == fold].reset_index(drop=True)
+
+        elif split == "test":
+            df = self._load_test_dataframe()
+            df["fold"] = -1
+
+        elif split == "all":
+            df = self._load_combined_dataframe()
+            df = self._assign_folds(df)
+
+            if fold is not None:
+                if all_mode == "train":
+                    df = df[df["fold"] != fold].reset_index(drop=True)
+                elif all_mode == "val":
+                    df = df[df["fold"] == fold].reset_index(drop=True)
+                elif all_mode == "all":
+                    df = df.reset_index(drop=True)
+            else:
+                df = df.reset_index(drop=True)
+
+        self.df = df.reset_index(drop=True)
+        self.samples = self._build_samples(self.df)
+
+        if len(self.samples) == 0:
+            raise RuntimeError(
+                f"No images found for split='{split}'. "
+                f"Check root path, CSV files, folders, and file extensions."
+            )
+
+        self._print_summary()
+
+    def _load_train_dataframe(self) -> pd.DataFrame:
+        path = self.root / "trainLabels.csv"
+        if not path.exists():
+            raise FileNotFoundError(f"Missing trainLabels.csv: {path}")
+
+        df = pd.read_csv(path)
+        return self._standardize_label_dataframe(df, source="train")
+
+    def _load_test_dataframe(self) -> pd.DataFrame:
+        path = self.root / "testLabels.csv"
+        if not path.exists():
+            raise FileNotFoundError(f"Missing testLabels.csv: {path}")
+
+        df = pd.read_csv(path)
+        return self._standardize_label_dataframe(df, source="test")
+
+    def _load_combined_dataframe(self) -> pd.DataFrame:
+        train_df = self._load_train_dataframe()
+        test_df = self._load_test_dataframe()
+
+        df = pd.concat([train_df, test_df], axis=0, ignore_index=True)
+        df = df.drop_duplicates(subset=["source", "image"]).reset_index(drop=True)
+
+        return df
+
+    @staticmethod
+    def _standardize_label_dataframe(df: pd.DataFrame, source: str) -> pd.DataFrame:
+        """
+        Standardize label dataframe to:
+            image, level, source, patient_id
+
+        EyePACS image names usually look like:
+            10_left
+            10_right
+
+        patient_id is extracted as the part before the first underscore.
+        """
+
+        if "image" not in df.columns:
+            raise ValueError(f"{source} labels CSV must contain column 'image'")
+
+        if "level" not in df.columns:
+            raise ValueError(f"{source} labels CSV must contain column 'level'")
+
+        df = df[["image", "level"]].copy()
+        df["image"] = df["image"].astype(str)
+        df["level"] = df["level"].astype(int)
+        df["source"] = source
+        df["patient_id"] = df["image"].str.split("_").str[0].astype(str)
+
+        return df
+
+    def _assign_folds(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Assign stratified group folds.
+
+        Grouping:
+            patient_id
+
+        Stratification label:
+            max DR severity across all images for that patient_id.
+
+        This keeps left/right eyes from the same patient in the same fold.
+        """
+
+        df = df.copy()
+
+        patient_df = (
+            df.groupby("patient_id", as_index=False)
+            .agg(patient_level=("level", "max"))
+            .reset_index(drop=True)
+        )
+
+        groups = patient_df["patient_id"].values
+        y = patient_df["patient_level"].values
+
+        splitter = StratifiedGroupKFold(
+            n_splits=self.n_folds,
+            shuffle=True,
+            random_state=self.seed,
+        )
+
+        patient_df["fold"] = -1
+
+        for fold_idx, (_, val_idx) in enumerate(
+            splitter.split(X=patient_df, y=y, groups=groups)
+        ):
+            patient_df.loc[val_idx, "fold"] = fold_idx
+
+        if (patient_df["fold"] < 0).any():
+            raise RuntimeError("Some patients were not assigned to a fold")
+
+        fold_map = dict(zip(patient_df["patient_id"], patient_df["fold"]))
+        df["fold"] = df["patient_id"].map(fold_map).astype(int)
+
+        return df
+
+    def _build_samples(self, df: pd.DataFrame):
+        samples = []
+        missing = []
+
+        for _, row in df.iterrows():
+            image_id = str(row["image"])
+            label = int(row["level"])
+            source = str(row["source"])
+            patient_id = str(row["patient_id"])
+            fold = int(row["fold"])
+
+            image_dir = self.root / source
+            image_path = self._find_image_path(image_dir, image_id)
+
+            if image_path is None:
+                missing.append((source, image_id))
+                continue
+
+            samples.append(
+                {
+                    "image_id": image_id,
+                    "image_path": image_path,
+                    "label": label,
+                    "source": source,
+                    "patient_id": patient_id,
+                    "fold": fold,
+                }
+            )
+
+        if len(missing) > 0:
+            print(
+                f"[EyePACSDataset] Warning: {len(missing)} images listed in CSV "
+                f"were not found on disk."
+            )
+            print(f"[EyePACSDataset] First few missing: {missing[:5]}")
+
+        return samples
+
+    def _find_image_path(self, image_dir: Path, image_id: str):
+        for ext in self.image_exts:
+            path = image_dir / f"{image_id}{ext}"
+            if path.exists():
+                return path
+        return None
+
+    def _print_summary(self):
+        labels = [s["label"] for s in self.samples]
+        counts = pd.Series(labels).value_counts().sort_index()
+
+        print(f"[EyePACSDataset] split={self.split}")
+        print(f"[EyePACSDataset] root={self.root}")
+        print(f"[EyePACSDataset] n={len(self.samples)}")
+
+        if self.split != "test":
+            print(
+                f"[EyePACSDataset] seed={self.seed}, "
+                f"fold={self.fold}, "
+                f"n_folds={self.n_folds}"
+            )
+
+        if self.split == "all":
+            print(f"[EyePACSDataset] all_mode={self.all_mode}")
+
+        print("[EyePACSDataset] source counts:")
+        source_counts = pd.Series([s["source"] for s in self.samples]).value_counts()
+        for source, count in source_counts.items():
+            print(f"  {source}: {int(count)}")
+
+        print("[EyePACSDataset] class counts:")
+        for cls in range(5):
+            print(f"  class {cls}: {int(counts.get(cls, 0))}")
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        sample = self.samples[idx]
+
+        image = Image.open(sample["image_path"]).convert("RGB")
+
+        if self.transform is not None:
+            image = self.transform(image)
+
+        label = torch.tensor(sample["label"], dtype=torch.long)
+
+        if self.return_path:
+            return {
+                "image": image,
+                "label": label,
+                "image_id": sample["image_id"],
+                "image_path": str(sample["image_path"]),
+                "source": sample["source"],
+                "patient_id": sample["patient_id"],
+                "fold": sample["fold"],
+            }
+
+        return image, label

model.py

@@ -0,0 +1,61 @@
+"""DeepSeeNet model definition."""
+
+from torch import Tensor, nn
+
+try:
+    import timm
+except ImportError:  # pragma: no cover - handled when timm is absent.
+    timm = None
+
+
+class DeepSeeNet(nn.Module):
+    """DeepSeeNet risk-factor classifier in PyTorch.
+
+    Args:
+        n_classes: Number of output classes.
+        backbone: Any timm model name that supports ``num_classes=0``. The
+            default uses InceptionV3.
+        pretrained: Load ImageNet weights for the backbone.
+        dropout: Dropout probability used by the classifier head.
+        freeze_backbone: If true, keep the backbone frozen and train only the
+            classifier head.
+    """
+
+    def __init__(
+        self,
+        n_classes: int = 2,
+        backbone: str = "inception_v3",
+        pretrained: bool = True,
+        dropout: float = 0.5,
+        freeze_backbone: bool = False,
+    ) -> None:
+        super().__init__()
+        if n_classes < 1:
+            raise ValueError("n_classes must be positive")
+        if timm is None:
+            raise ImportError("timm is required to build DeepSeeNet")
+
+        self.backbone_name = backbone
+        self.backbone = timm.create_model(
+            backbone,
+            pretrained=pretrained,
+            num_classes=0,
+            global_pool="avg",
+        )
+        in_features = self.backbone.num_features
+        self.classifier = nn.Sequential(
+            nn.Linear(in_features, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(dropout),
+            nn.Linear(256, 128),
+            nn.ReLU(inplace=True),
+            nn.Dropout(dropout),
+            nn.Linear(128, n_classes),
+        )
+
+        if freeze_backbone:
+            self.backbone.requires_grad_(False)
+
+    def forward(self, x: Tensor) -> Tensor:
+        features = self.backbone(x)
+        return self.classifier(features)

requirements.txt

@@ -0,0 +1,13 @@
+albumentations
+gradio
+huggingface_hub
+numpy
+opencv-python
+pandas
+pillow
+pydantic
+timm
+torch
+torchvision
+torchaudio
+tqdm

runs/eyepacs_dr/inception_v3_fold0/best_model_only.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dce962b4cc7a2c70bff55de17f3df89c1ff8c03fb881a681591377794d0c19de
+size 89735243

runs/eyepacs_dr/inception_v3_fold0/history.json

@@ -0,0 +1,287 @@
+[
+  {
+    "epoch": 1,
+    "lr": 0.0001,
+    "train_loss": 1.2191880825112196,
+    "train_acc": 0.5508288227334236,
+    "val_loss": 0.8676833006413706,
+    "val_acc": 0.7436865839909809,
+    "val_referable_acc": 0.9082863585118377,
+    "val_any_dr_acc": 0.8395152198421646,
+    "val_severe_or_pdr_acc": 0.9364712514092447,
+    "val_qwk": 0.7140886061578311,
+    "val_referable_auc": 0.924552902315247,
+    "val_any_dr_auc": 0.879340733543783,
+    "val_severe_or_pdr_auc": 0.9729235633730084
+  },
+  {
+    "epoch": 2,
+    "lr": 9.972883382072954e-05,
+    "train_loss": 1.0452303189547363,
+    "train_acc": 0.6802125620207488,
+    "val_loss": 0.7482551874544602,
+    "val_acc": 0.7671927846674182,
+    "val_referable_acc": 0.9131341600901917,
+    "val_any_dr_acc": 0.8613866967305525,
+    "val_severe_or_pdr_acc": 0.9496054114994363,
+    "val_qwk": 0.7584975852550456,
+    "val_referable_auc": 0.9301897769832052,
+    "val_any_dr_auc": 0.9032338758891758,
+    "val_severe_or_pdr_auc": 0.9757942542713257
+  },
+  {
+    "epoch": 3,
+    "lr": 9.891830623632339e-05,
+    "train_loss": 0.9849801756774298,
+    "train_acc": 0.719539354984213,
+    "val_loss": 0.8034545580053276,
+    "val_acc": 0.7496617812852311,
+    "val_referable_acc": 0.9096392333709132,
+    "val_any_dr_acc": 0.8586245772266066,
+    "val_severe_or_pdr_acc": 0.9195603156708004,
+    "val_qwk": 0.7155813958918468,
+    "val_referable_auc": 0.9341313162498839,
+    "val_any_dr_auc": 0.9124605325061405,
+    "val_severe_or_pdr_auc": 0.9746139125395339
+  },
+  {
+    "epoch": 4,
+    "lr": 9.757729755661011e-05,
+    "train_loss": 0.9430840012588424,
+    "train_acc": 0.740978800180424,
+    "val_loss": 0.7264118472107906,
+    "val_acc": 0.7847801578354002,
+    "val_referable_acc": 0.9155016910935738,
+    "val_any_dr_acc": 0.8696166854565953,
+    "val_severe_or_pdr_acc": 0.9439684329199549,
+    "val_qwk": 0.7404066770264675,
+    "val_referable_auc": 0.9430007323088389,
+    "val_any_dr_auc": 0.918949293829938,
+    "val_severe_or_pdr_auc": 0.9757122141043169
+  },
+  {
+    "epoch": 5,
+    "lr": 9.572050015330873e-05,
+    "train_loss": 0.9146992052977936,
+    "train_acc": 0.756441700496166,
+    "val_loss": 0.6687679942323498,
+    "val_acc": 0.8094701240135288,
+    "val_referable_acc": 0.913641488162345,
+    "val_any_dr_acc": 0.8978015783540022,
+    "val_severe_or_pdr_acc": 0.9494363021420519,
+    "val_qwk": 0.7657158782341715,
+    "val_referable_auc": 0.9439605662828892,
+    "val_any_dr_auc": 0.9205573987730261,
+    "val_severe_or_pdr_auc": 0.9773371098739827
+  },
+  {
+    "epoch": 6,
+    "lr": 9.336825748732972e-05,
+    "train_loss": 0.882006509337922,
+    "train_acc": 0.7686485115020297,
+    "val_loss": 0.7364799950544837,
+    "val_acc": 0.7890642615558061,
+    "val_referable_acc": 0.913923337091319,
+    "val_any_dr_acc": 0.8679819616685457,
+    "val_severe_or_pdr_acc": 0.9467305524239008,
+    "val_qwk": 0.7378029189144739,
+    "val_referable_auc": 0.9429656239713404,
+    "val_any_dr_auc": 0.9224749898528801,
+    "val_severe_or_pdr_auc": 0.9758237458346295
+  },
+  {
+    "epoch": 7,
+    "lr": 9.05463412215599e-05,
+    "train_loss": 0.8602466160817139,
+    "train_acc": 0.7752311682453766,
+    "val_loss": 0.6406958381245343,
+    "val_acc": 0.8077226606538895,
+    "val_referable_acc": 0.9151071025930101,
+    "val_any_dr_acc": 0.8822998872604284,
+    "val_severe_or_pdr_acc": 0.9576099210822999,
+    "val_qwk": 0.7721192161837538,
+    "val_referable_auc": 0.9449475727317759,
+    "val_any_dr_auc": 0.9233336916673446,
+    "val_severe_or_pdr_auc": 0.9767672256289048
+  },
+  {
+    "epoch": 8,
+    "lr": 8.728566886113101e-05,
+    "train_loss": 0.8290294695126349,
+    "train_acc": 0.779967298150654,
+    "val_loss": 0.6343717073507212,
+    "val_acc": 0.8144870349492672,
+    "val_referable_acc": 0.9237880496054115,
+    "val_any_dr_acc": 0.8870349492671927,
+    "val_severe_or_pdr_acc": 0.9634160090191657,
+    "val_qwk": 0.8033455171949371,
+    "val_referable_auc": 0.9489161527156735,
+    "val_any_dr_auc": 0.9277659781884949,
+    "val_severe_or_pdr_auc": 0.9800201271876396
+  },
+  {
+    "epoch": 9,
+    "lr": 8.362196501476347e-05,
+    "train_loss": 0.8049967132162607,
+    "train_acc": 0.7827582318448354,
+    "val_loss": 0.6686938404633738,
+    "val_acc": 0.7877677564825254,
+    "val_referable_acc": 0.9228297632468997,
+    "val_any_dr_acc": 0.8662908680947012,
+    "val_severe_or_pdr_acc": 0.9598647125140924,
+    "val_qwk": 0.7868667085078025,
+    "val_referable_auc": 0.948626316362486,
+    "val_any_dr_auc": 0.9289171459554377,
+    "val_severe_or_pdr_auc": 0.9788885805878594
+  },
+  {
+    "epoch": 10,
+    "lr": 7.959536998847741e-05,
+    "train_loss": 0.7784485263522273,
+    "train_acc": 0.7822789806044204,
+    "val_loss": 0.6502069805493618,
+    "val_acc": 0.7921082299887261,
+    "val_referable_acc": 0.9254227733934611,
+    "val_any_dr_acc": 0.8756482525366404,
+    "val_severe_or_pdr_acc": 0.9478579481397971,
+    "val_qwk": 0.7910244571190812,
+    "val_referable_auc": 0.9516418326868392,
+    "val_any_dr_auc": 0.9282227682160731,
+    "val_severe_or_pdr_auc": 0.9795037924720514
+  },
+  {
+    "epoch": 11,
+    "lr": 7.524999999999999e-05,
+    "train_loss": 0.7509459461924403,
+    "train_acc": 0.7843510374379793,
+    "val_loss": 0.6940719285839171,
+    "val_acc": 0.7910372040586245,
+    "val_referable_acc": 0.9186020293122886,
+    "val_any_dr_acc": 0.8686583990980834,
+    "val_severe_or_pdr_acc": 0.9589627959413755,
+    "val_qwk": 0.7803465132729354,
+    "val_referable_auc": 0.9472788109365553,
+    "val_any_dr_auc": 0.9282660544196276,
+    "val_severe_or_pdr_auc": 0.9756903724737973
+  },
+  {
+    "epoch": 12,
+    "lr": 7.06334638322521e-05,
+    "train_loss": 0.7224059543149344,
+    "train_acc": 0.790581303563374,
+    "val_loss": 0.6284573407157029,
+    "val_acc": 0.8084554678692221,
+    "val_referable_acc": 0.9204622322435174,
+    "val_any_dr_acc": 0.8856820744081173,
+    "val_severe_or_pdr_acc": 0.9538331454340474,
+    "val_qwk": 0.7859381302661944,
+    "val_referable_auc": 0.949624795859308,
+    "val_any_dr_auc": 0.9286386672917757,
+    "val_severe_or_pdr_auc": 0.9782240016140643
+  },
+  {
+    "epoch": 13,
+    "lr": 6.579634122155988e-05,
+    "train_loss": 0.678931502343891,
+    "train_acc": 0.8054239963915201,
+    "val_loss": 0.6790591289521339,
+    "val_acc": 0.7918827508455468,
+    "val_referable_acc": 0.9203494926719279,
+    "val_any_dr_acc": 0.8708004509582864,
+    "val_severe_or_pdr_acc": 0.9526493799323562,
+    "val_qwk": 0.7776873128462451,
+    "val_referable_auc": 0.9484067777659061,
+    "val_any_dr_auc": 0.9263266363022873,
+    "val_severe_or_pdr_auc": 0.9759889700838298
+  },
+  {
+    "epoch": 14,
+    "lr": 6.079162869547907e-05,
+    "train_loss": 0.65180876729426,
+    "train_acc": 0.8017450383400992,
+    "val_loss": 0.635306676372197,
+    "val_acc": 0.8014656144306652,
+    "val_referable_acc": 0.9195039458850056,
+    "val_any_dr_acc": 0.8771138669673055,
+    "val_severe_or_pdr_acc": 0.957271702367531,
+    "val_qwk": 0.7925515495846708,
+    "val_referable_auc": 0.9500388593755204,
+    "val_any_dr_auc": 0.9308198505052305,
+    "val_severe_or_pdr_auc": 0.976161594034368
+  },
+  {
+    "epoch": 15,
+    "lr": 5.567415893174884e-05,
+    "train_loss": 0.61246272180873,
+    "train_acc": 0.8109212900315742,
+    "val_loss": 0.6278831657186033,
+    "val_acc": 0.7925028184892897,
+    "val_referable_acc": 0.9235625704622322,
+    "val_any_dr_acc": 0.8679255918827509,
+    "val_severe_or_pdr_acc": 0.9588500563697858,
+    "val_qwk": 0.8006316582640922,
+    "val_referable_auc": 0.9499428891538771,
+    "val_any_dr_auc": 0.9269722669912654,
+    "val_severe_or_pdr_auc": 0.9790055816626393
+  },
+  {
+    "epoch": 16,
+    "lr": 5.05e-05,
+    "train_loss": 0.5845572758309735,
+    "train_acc": 0.8146425349571493,
+    "val_loss": 0.6543550435289858,
+    "val_acc": 0.7959977452085683,
+    "val_referable_acc": 0.9232807215332581,
+    "val_any_dr_acc": 0.8736753100338218,
+    "val_severe_or_pdr_acc": 0.9649379932356257,
+    "val_qwk": 0.8075519604379204,
+    "val_referable_auc": 0.9482329286570407,
+    "val_any_dr_auc": 0.9286975430685462,
+    "val_severe_or_pdr_auc": 0.9758107695467758
+  },
+  {
+    "epoch": 17,
+    "lr": 4.532584106825115e-05,
+    "train_loss": 0.5447519773001546,
+    "train_acc": 0.821521199819576,
+    "val_loss": 0.6652101601796327,
+    "val_acc": 0.7871476888387824,
+    "val_referable_acc": 0.923055242390079,
+    "val_any_dr_acc": 0.8653325817361894,
+    "val_severe_or_pdr_acc": 0.961837655016911,
+    "val_qwk": 0.791314256809605,
+    "val_referable_auc": 0.9438051936460965,
+    "val_any_dr_auc": 0.9265324644482931,
+    "val_severe_or_pdr_auc": 0.9767693704698723
+  },
+  {
+    "epoch": 18,
+    "lr": 4.0208371304520894e-05,
+    "train_loss": 0.5182197611740327,
+    "train_acc": 0.8213379566982408,
+    "val_loss": 0.6194416342485851,
+    "val_acc": 0.7971815107102593,
+    "val_referable_acc": 0.9248590755355129,
+    "val_any_dr_acc": 0.8734498308906427,
+    "val_severe_or_pdr_acc": 0.9632468996617812,
+    "val_qwk": 0.8099503330099491,
+    "val_referable_auc": 0.9476082860622475,
+    "val_any_dr_auc": 0.9269798287926418,
+    "val_severe_or_pdr_auc": 0.9785031884133404
+  },
+  {
+    "epoch": 19,
+    "lr": 3.520365877844009e-05,
+    "train_loss": 0.4779584521766337,
+    "train_acc": 0.8299503834009924,
+    "val_loss": 0.6388505003094808,
+    "val_acc": 0.8011837655016911,
+    "val_referable_acc": 0.9214768883878242,
+    "val_any_dr_acc": 0.8696166854565953,
+    "val_severe_or_pdr_acc": 0.9637542277339346,
+    "val_qwk": 0.7931194428109762,
+    "val_referable_auc": 0.9505122746308755,
+    "val_any_dr_auc": 0.9300419577789887,
+    "val_severe_or_pdr_auc": 0.9751037227218233
+  }
+]

runs/eyepacs_dr/inception_v3_fold1/best_model_only.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:065898a2a70eb2c96da5c2c78efacc5f29dc66a6394af397bb0f761cf7527cb1
+size 89735243

runs/eyepacs_dr/inception_v3_fold1/history.json

@@ -0,0 +1,287 @@
+[
+  {
+    "epoch": 1,
+    "lr": 0.0001,
+    "train_loss": 1.2026121128933571,
+    "train_acc": 0.553168696436626,
+    "val_loss": 0.8374152492743148,
+    "val_acc": 0.7521136286777139,
+    "val_referable_acc": 0.8970803742531845,
+    "val_any_dr_acc": 0.8385751324540638,
+    "val_severe_or_pdr_acc": 0.9418329387893135,
+    "val_qwk": 0.6836796861912281,
+    "val_referable_auc": 0.9156936050415827,
+    "val_any_dr_auc": 0.8720412184915984,
+    "val_severe_or_pdr_auc": 0.9578836845029959
+  },
+  {
+    "epoch": 2,
+    "lr": 9.972883382072954e-05,
+    "train_loss": 1.0318292616238507,
+    "train_acc": 0.6790426251691475,
+    "val_loss": 0.7552449644290532,
+    "val_acc": 0.7826626084996054,
+    "val_referable_acc": 0.9076766993574569,
+    "val_any_dr_acc": 0.871491376394995,
+    "val_severe_or_pdr_acc": 0.9453838349678728,
+    "val_qwk": 0.7235517054346978,
+    "val_referable_auc": 0.9167888976621349,
+    "val_any_dr_auc": 0.8932112253636199,
+    "val_severe_or_pdr_auc": 0.9604115897123635
+  },
+  {
+    "epoch": 3,
+    "lr": 9.891830623632339e-05,
+    "train_loss": 0.9734103289551707,
+    "train_acc": 0.726009246729815,
+    "val_loss": 0.7190881273400056,
+    "val_acc": 0.8057152519445384,
+    "val_referable_acc": 0.9196821102468719,
+    "val_any_dr_acc": 0.8854695073836095,
+    "val_severe_or_pdr_acc": 0.9467365573216098,
+    "val_qwk": 0.7489601682632545,
+    "val_referable_auc": 0.937417607330826,
+    "val_any_dr_auc": 0.907371009956367,
+    "val_severe_or_pdr_auc": 0.963622201448665
+  },
+  {
+    "epoch": 4,
+    "lr": 9.757729755661011e-05,
+    "train_loss": 0.9321129762029454,
+    "train_acc": 0.7482380469102391,
+    "val_loss": 0.7095937849757449,
+    "val_acc": 0.7950061999774546,
+    "val_referable_acc": 0.921373013189043,
+    "val_any_dr_acc": 0.8789313493405478,
+    "val_severe_or_pdr_acc": 0.9477510990869125,
+    "val_qwk": 0.762886911264498,
+    "val_referable_auc": 0.9420763854554339,
+    "val_any_dr_auc": 0.9133179603379078,
+    "val_severe_or_pdr_auc": 0.9666140768371154
+  },
+  {
+    "epoch": 5,
+    "lr": 9.572050015330873e-05,
+    "train_loss": 0.9010974023193726,
+    "train_acc": 0.7627565403698692,
+    "val_loss": 0.7568363213052665,
+    "val_acc": 0.7908353060534326,
+    "val_referable_acc": 0.9201330176981175,
+    "val_any_dr_acc": 0.8696877465900124,
+    "val_severe_or_pdr_acc": 0.9524856273249915,
+    "val_qwk": 0.7572223845133317,
+    "val_referable_auc": 0.9399529114467903,
+    "val_any_dr_auc": 0.913509437130183,
+    "val_severe_or_pdr_auc": 0.9651894407755202
+  },
+  {
+    "epoch": 6,
+    "lr": 9.336825748732972e-05,
+    "train_loss": 0.8704525511249745,
+    "train_acc": 0.7721865133062698,
+    "val_loss": 0.8010236610219734,
+    "val_acc": 0.7685153872167737,
+    "val_referable_acc": 0.8974185548416188,
+    "val_any_dr_acc": 0.8616841393304024,
+    "val_severe_or_pdr_acc": 0.9301093450569271,
+    "val_qwk": 0.7133115474233512,
+    "val_referable_auc": 0.9472766142977672,
+    "val_any_dr_auc": 0.9200055280370211,
+    "val_severe_or_pdr_auc": 0.9665115217625493
+  },
+  {
+    "epoch": 7,
+    "lr": 9.05463412215599e-05,
+    "train_loss": 0.8321962211924627,
+    "train_acc": 0.775625845737483,
+    "val_loss": 0.7558084888464165,
+    "val_acc": 0.7736444594746928,
+    "val_referable_acc": 0.9060985232780971,
+    "val_any_dr_acc": 0.8678841167850299,
+    "val_severe_or_pdr_acc": 0.9163566677939353,
+    "val_qwk": 0.6786061720857763,
+    "val_referable_auc": 0.9403188664966133,
+    "val_any_dr_auc": 0.9191492215314945,
+    "val_severe_or_pdr_auc": 0.9615996734543758
+  },
+  {
+    "epoch": 8,
+    "lr": 8.728566886113101e-05,
+    "train_loss": 0.8177962298792765,
+    "train_acc": 0.7858451736580965,
+    "val_loss": 0.6457110616779425,
+    "val_acc": 0.8106188704768347,
+    "val_referable_acc": 0.9237402773080825,
+    "val_any_dr_acc": 0.8930222071919739,
+    "val_severe_or_pdr_acc": 0.9468492841844212,
+    "val_qwk": 0.7714119068915228,
+    "val_referable_auc": 0.9457900718012293,
+    "val_any_dr_auc": 0.9203518908286116,
+    "val_severe_or_pdr_auc": 0.9663216986230594
+  },
+  {
+    "epoch": 9,
+    "lr": 8.362196501476347e-05,
+    "train_loss": 0.7908911250588805,
+    "train_acc": 0.7856619305367614,
+    "val_loss": 0.6637757030902459,
+    "val_acc": 0.8100552361627776,
+    "val_referable_acc": 0.9274039003494533,
+    "val_any_dr_acc": 0.8876113177770263,
+    "val_severe_or_pdr_acc": 0.956205613797768,
+    "val_qwk": 0.8006692611738406,
+    "val_referable_auc": 0.9488354745793148,
+    "val_any_dr_auc": 0.9206744634585085,
+    "val_severe_or_pdr_auc": 0.9689028630191081
+  },
+  {
+    "epoch": 10,
+    "lr": 7.959536998847741e-05,
+    "train_loss": 0.7643525296428153,
+    "train_acc": 0.7932876635092467,
+    "val_loss": 0.6757383593818459,
+    "val_acc": 0.7982752789989854,
+    "val_referable_acc": 0.9256566339758765,
+    "val_any_dr_acc": 0.8783677150264908,
+    "val_severe_or_pdr_acc": 0.948596550557998,
+    "val_qwk": 0.7795822369761995,
+    "val_referable_auc": 0.952180940819946,
+    "val_any_dr_auc": 0.9246441342557743,
+    "val_severe_or_pdr_auc": 0.9664718510288837
+  },
+  {
+    "epoch": 11,
+    "lr": 7.524999999999999e-05,
+    "train_loss": 0.7334291298928753,
+    "train_acc": 0.7942320703653586,
+    "val_loss": 0.6057324167330496,
+    "val_acc": 0.8163115770488107,
+    "val_referable_acc": 0.9269529928982077,
+    "val_any_dr_acc": 0.891274940818397,
+    "val_severe_or_pdr_acc": 0.9563747040919851,
+    "val_qwk": 0.7900845705555817,
+    "val_referable_auc": 0.9473444224703329,
+    "val_any_dr_auc": 0.9199220043277607,
+    "val_severe_or_pdr_auc": 0.9659417503784572
+  },
+  {
+    "epoch": 12,
+    "lr": 7.06334638322521e-05,
+    "train_loss": 0.6972404156026402,
+    "train_acc": 0.7989118177717637,
+    "val_loss": 0.7115337061594444,
+    "val_acc": 0.778942622026829,
+    "val_referable_acc": 0.914891218577387,
+    "val_any_dr_acc": 0.857569608837786,
+    "val_severe_or_pdr_acc": 0.9541765302671626,
+    "val_qwk": 0.773439823813228,
+    "val_referable_auc": 0.9498813971927252,
+    "val_any_dr_auc": 0.9262803122554194,
+    "val_severe_or_pdr_auc": 0.9691176738138658
+  },
+  {
+    "epoch": 13,
+    "lr": 6.579634122155988e-05,
+    "train_loss": 0.6745618633862063,
+    "train_acc": 0.8047615020297699,
+    "val_loss": 0.6478154543972434,
+    "val_acc": 0.803686168413933,
+    "val_referable_acc": 0.9209221057377973,
+    "val_any_dr_acc": 0.8797768008116335,
+    "val_severe_or_pdr_acc": 0.9530492616390486,
+    "val_qwk": 0.7809586848122757,
+    "val_referable_auc": 0.9476525109932052,
+    "val_any_dr_auc": 0.9234389081104144,
+    "val_severe_or_pdr_auc": 0.9665842954775892
+  },
+  {
+    "epoch": 14,
+    "lr": 6.079162869547907e-05,
+    "train_loss": 0.6390304281857296,
+    "train_acc": 0.8057481957600361,
+    "val_loss": 0.6064365419026172,
+    "val_acc": 0.8143388569496111,
+    "val_referable_acc": 0.9259948145643107,
+    "val_any_dr_acc": 0.8916131214068312,
+    "val_severe_or_pdr_acc": 0.9585165144854019,
+    "val_qwk": 0.8013380815188119,
+    "val_referable_auc": 0.9495913061231518,
+    "val_any_dr_auc": 0.9251410560727309,
+    "val_severe_or_pdr_auc": 0.9679007523548978
+  },
+  {
+    "epoch": 15,
+    "lr": 5.567415893174884e-05,
+    "train_loss": 0.6031589889693055,
+    "train_acc": 0.8134444068561119,
+    "val_loss": 0.6843524756311712,
+    "val_acc": 0.7870589561492504,
+    "val_referable_acc": 0.9243602750535452,
+    "val_any_dr_acc": 0.8676586630594071,
+    "val_severe_or_pdr_acc": 0.9522038101679631,
+    "val_qwk": 0.7926764678375114,
+    "val_referable_auc": 0.9519691120245126,
+    "val_any_dr_auc": 0.9264247004258922,
+    "val_severe_or_pdr_auc": 0.9699912226142658
+  },
+  {
+    "epoch": 16,
+    "lr": 5.05e-05,
+    "train_loss": 0.5689867827125535,
+    "train_acc": 0.8199988723500226,
+    "val_loss": 0.6491324536064783,
+    "val_acc": 0.8049825273362642,
+    "val_referable_acc": 0.9251493630932252,
+    "val_any_dr_acc": 0.8824258820877015,
+    "val_severe_or_pdr_acc": 0.9555856160523053,
+    "val_qwk": 0.7875070071285253,
+    "val_referable_auc": 0.945414267347864,
+    "val_any_dr_auc": 0.9243323626706975,
+    "val_severe_or_pdr_auc": 0.9674251942450486
+  },
+  {
+    "epoch": 17,
+    "lr": 4.532584106825115e-05,
+    "train_loss": 0.5425662958560142,
+    "train_acc": 0.820872801082544,
+    "val_loss": 0.6018754473910796,
+    "val_acc": 0.8186224777364446,
+    "val_referable_acc": 0.9275166272122647,
+    "val_any_dr_acc": 0.8925712997407282,
+    "val_severe_or_pdr_acc": 0.9621801375267727,
+    "val_qwk": 0.8065342569653287,
+    "val_referable_auc": 0.9471525794573215,
+    "val_any_dr_auc": 0.9243262164008834,
+    "val_severe_or_pdr_auc": 0.9677116841294643
+  },
+  {
+    "epoch": 18,
+    "lr": 4.0208371304520894e-05,
+    "train_loss": 0.5011885827445048,
+    "train_acc": 0.83247350022553,
+    "val_loss": 0.6446213349053266,
+    "val_acc": 0.809040694397475,
+    "val_referable_acc": 0.9258820877014993,
+    "val_any_dr_acc": 0.8854695073836095,
+    "val_severe_or_pdr_acc": 0.962123774095367,
+    "val_qwk": 0.8019418515785007,
+    "val_referable_auc": 0.9391693765337806,
+    "val_any_dr_auc": 0.9214470823542462,
+    "val_severe_or_pdr_auc": 0.9675130662412171
+  },
+  {
+    "epoch": 19,
+    "lr": 3.520365877844009e-05,
+    "train_loss": 0.47397731046285185,
+    "train_acc": 0.8359974064050518,
+    "val_loss": 0.6219859553383217,
+    "val_acc": 0.8104497801826175,
+    "val_referable_acc": 0.9272911734866419,
+    "val_any_dr_acc": 0.8833840604215984,
+    "val_severe_or_pdr_acc": 0.9569383384060421,
+    "val_qwk": 0.7980956613043054,
+    "val_referable_auc": 0.9491089108302032,
+    "val_any_dr_auc": 0.9246982460152176,
+    "val_severe_or_pdr_auc": 0.9674015654350823
+  }
+]

runs/eyepacs_dr/inception_v3_fold2/best_model_only.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e11288258bff638027be0a4956da8992931c25ccdac7b635fb542be6eb0c05f
+size 89735243

runs/eyepacs_dr/inception_v3_fold2/history.json

@@ -0,0 +1,257 @@
+[
+  {
+    "epoch": 1,
+    "lr": 0.0001,
+    "train_loss": 1.2143506749987225,
+    "train_acc": 0.5614710193955796,
+    "val_loss": 0.6948825628539755,
+    "val_acc": 0.7953776775648252,
+    "val_referable_acc": 0.9081172491544532,
+    "val_any_dr_acc": 0.8778466741826381,
+    "val_severe_or_pdr_acc": 0.9413190529875987,
+    "val_qwk": 0.7155456574787837,
+    "val_referable_auc": 0.9247314923272769,
+    "val_any_dr_auc": 0.8790872092642767,
+    "val_severe_or_pdr_auc": 0.9670086693426698
+  },
+  {
+    "epoch": 2,
+    "lr": 9.972883382072954e-05,
+    "train_loss": 1.0420125438304544,
+    "train_acc": 0.6888390843482183,
+    "val_loss": 0.8327976735630057,
+    "val_acc": 0.6973506200676437,
+    "val_referable_acc": 0.9091319052987599,
+    "val_any_dr_acc": 0.7968996617812852,
+    "val_severe_or_pdr_acc": 0.9479143179255919,
+    "val_qwk": 0.7231192710199451,
+    "val_referable_auc": 0.9336409757639126,
+    "val_any_dr_auc": 0.8999365600581144,
+    "val_severe_or_pdr_auc": 0.9717771882818815
+  },
+  {
+    "epoch": 3,
+    "lr": 9.891830623632339e-05,
+    "train_loss": 0.985259113020869,
+    "train_acc": 0.7269959404600812,
+    "val_loss": 0.7072824161512339,
+    "val_acc": 0.7739571589627959,
+    "val_referable_acc": 0.9163472378804961,
+    "val_any_dr_acc": 0.86967305524239,
+    "val_severe_or_pdr_acc": 0.9385569334836528,
+    "val_qwk": 0.7451868136032376,
+    "val_referable_auc": 0.9428887353837985,
+    "val_any_dr_auc": 0.9123166499784034,
+    "val_severe_or_pdr_auc": 0.9740952162696138
+  },
+  {
+    "epoch": 4,
+    "lr": 9.757729755661011e-05,
+    "train_loss": 0.9373754202970042,
+    "train_acc": 0.7481111862877763,
+    "val_loss": 0.7193142563944604,
+    "val_acc": 0.7816234498308906,
+    "val_referable_acc": 0.918489289740699,
+    "val_any_dr_acc": 0.8700112739571589,
+    "val_severe_or_pdr_acc": 0.9522547914317926,
+    "val_qwk": 0.7620895041226018,
+    "val_referable_auc": 0.9451858199028286,
+    "val_any_dr_auc": 0.9131514312639888,
+    "val_severe_or_pdr_auc": 0.9744336137071168
+  },
+  {
+    "epoch": 5,
+    "lr": 9.572050015330873e-05,
+    "train_loss": 0.9043582667893636,
+    "train_acc": 0.7615584122688318,
+    "val_loss": 0.6663910818341888,
+    "val_acc": 0.8056369785794814,
+    "val_referable_acc": 0.9179255918827508,
+    "val_any_dr_acc": 0.8842164599774521,
+    "val_severe_or_pdr_acc": 0.9594137542277339,
+    "val_qwk": 0.7709031226321263,
+    "val_referable_auc": 0.9445627977133615,
+    "val_any_dr_auc": 0.9151006204107276,
+    "val_severe_or_pdr_auc": 0.9724197038400002
+  },
+  {
+    "epoch": 6,
+    "lr": 9.336825748732972e-05,
+    "train_loss": 0.8722681901478585,
+    "train_acc": 0.7702554127198917,
+    "val_loss": 0.7913296779489571,
+    "val_acc": 0.7606538895152198,
+    "val_referable_acc": 0.9029312288613304,
+    "val_any_dr_acc": 0.8507891770011274,
+    "val_severe_or_pdr_acc": 0.9457158962795942,
+    "val_qwk": 0.7080191690735049,
+    "val_referable_auc": 0.9269965806304334,
+    "val_any_dr_auc": 0.9172570957840867,
+    "val_severe_or_pdr_auc": 0.9683691666705453
+  },
+  {
+    "epoch": 7,
+    "lr": 9.05463412215599e-05,
+    "train_loss": 0.8582366131410762,
+    "train_acc": 0.7776133288227334,
+    "val_loss": 0.6967431294608949,
+    "val_acc": 0.7959413754227734,
+    "val_referable_acc": 0.9282412626832018,
+    "val_any_dr_acc": 0.8834836527621195,
+    "val_severe_or_pdr_acc": 0.9430665163472379,
+    "val_qwk": 0.7790565442854828,
+    "val_referable_auc": 0.9510393498401439,
+    "val_any_dr_auc": 0.91728786272431,
+    "val_severe_or_pdr_auc": 0.9742298955685044
+  },
+  {
+    "epoch": 8,
+    "lr": 8.728566886113101e-05,
+    "train_loss": 0.8172618988388877,
+    "train_acc": 0.7812077131258457,
+    "val_loss": 0.7357572990044398,
+    "val_acc": 0.7737880496054115,
+    "val_referable_acc": 0.922435174746336,
+    "val_any_dr_acc": 0.8633596392333709,
+    "val_severe_or_pdr_acc": 0.9395152198421646,
+    "val_qwk": 0.7589173021521816,
+    "val_referable_auc": 0.9514882719851434,
+    "val_any_dr_auc": 0.9188145524927684,
+    "val_severe_or_pdr_auc": 0.9749677874156344
+  },
+  {
+    "epoch": 9,
+    "lr": 8.362196501476347e-05,
+    "train_loss": 0.7983663257616406,
+    "train_acc": 0.785281348669373,
+    "val_loss": 0.6312644582321572,
+    "val_acc": 0.8122886133032694,
+    "val_referable_acc": 0.9180947012401353,
+    "val_any_dr_acc": 0.8882750845546787,
+    "val_severe_or_pdr_acc": 0.9629650507328072,
+    "val_qwk": 0.7852212513783992,
+    "val_referable_auc": 0.9459528860088998,
+    "val_any_dr_auc": 0.9226028127904086,
+    "val_severe_or_pdr_auc": 0.9741718275877431
+  },
+  {
+    "epoch": 10,
+    "lr": 7.959536998847741e-05,
+    "train_loss": 0.7734421917216757,
+    "train_acc": 0.7890025935949482,
+    "val_loss": 0.652807928448734,
+    "val_acc": 0.7968996617812852,
+    "val_referable_acc": 0.9205186020293122,
+    "val_any_dr_acc": 0.8818489289740699,
+    "val_severe_or_pdr_acc": 0.9560315670800451,
+    "val_qwk": 0.7862390587287141,
+    "val_referable_auc": 0.9485443458714957,
+    "val_any_dr_auc": 0.9240858103951519,
+    "val_severe_or_pdr_auc": 0.9748014514631099
+  },
+  {
+    "epoch": 11,
+    "lr": 7.524999999999999e-05,
+    "train_loss": 0.7356365497552118,
+    "train_acc": 0.7935413847541724,
+    "val_loss": 0.6950417665376201,
+    "val_acc": 0.8027057497181511,
+    "val_referable_acc": 0.9224915445321308,
+    "val_any_dr_acc": 0.8719278466741827,
+    "val_severe_or_pdr_acc": 0.9626268320180383,
+    "val_qwk": 0.7840566914760235,
+    "val_referable_auc": 0.9528219758380423,
+    "val_any_dr_auc": 0.9236595806992055,
+    "val_severe_or_pdr_auc": 0.9734454237444407
+  },
+  {
+    "epoch": 12,
+    "lr": 7.06334638322521e-05,
+    "train_loss": 0.703734042397694,
+    "train_acc": 0.7984607577807848,
+    "val_loss": 0.7197710200657033,
+    "val_acc": 0.7735625704622322,
+    "val_referable_acc": 0.921815107102593,
+    "val_any_dr_acc": 0.8545095828635851,
+    "val_severe_or_pdr_acc": 0.9510710259301015,
+    "val_qwk": 0.7837397715419365,
+    "val_referable_auc": 0.9540776393967962,
+    "val_any_dr_auc": 0.9251081219486657,
+    "val_severe_or_pdr_auc": 0.9740435387218498
+  },
+  {
+    "epoch": 13,
+    "lr": 6.579634122155988e-05,
+    "train_loss": 0.6775929662401095,
+    "train_acc": 0.7984607577807848,
+    "val_loss": 0.7374675619427489,
+    "val_acc": 0.7498872604284104,
+    "val_referable_acc": 0.9068771138669673,
+    "val_any_dr_acc": 0.8481397970687712,
+    "val_severe_or_pdr_acc": 0.9284667418263811,
+    "val_qwk": 0.7465711006115658,
+    "val_referable_auc": 0.9518734454790881,
+    "val_any_dr_auc": 0.9208624478082748,
+    "val_severe_or_pdr_auc": 0.9757295048655574
+  },
+  {
+    "epoch": 14,
+    "lr": 6.079162869547907e-05,
+    "train_loss": 0.63867224941772,
+    "train_acc": 0.8038875732972486,
+    "val_loss": 0.638574194605751,
+    "val_acc": 0.7966178128523111,
+    "val_referable_acc": 0.9206877113866967,
+    "val_any_dr_acc": 0.8729988726042841,
+    "val_severe_or_pdr_acc": 0.9561443066516347,
+    "val_qwk": 0.7783495078517592,
+    "val_referable_auc": 0.9506779043335899,
+    "val_any_dr_auc": 0.9251737460897108,
+    "val_severe_or_pdr_auc": 0.9743007813541793
+  },
+  {
+    "epoch": 15,
+    "lr": 5.567415893174884e-05,
+    "train_loss": 0.6125179093547861,
+    "train_acc": 0.8125563824988723,
+    "val_loss": 0.6638782870137839,
+    "val_acc": 0.7777339346110484,
+    "val_referable_acc": 0.9192784667418263,
+    "val_any_dr_acc": 0.8587373167981962,
+    "val_severe_or_pdr_acc": 0.951803833145434,
+    "val_qwk": 0.7777181287118557,
+    "val_referable_auc": 0.9527175361264195,
+    "val_any_dr_auc": 0.9251897062865668,
+    "val_severe_or_pdr_auc": 0.9756308410127499
+  },
+  {
+    "epoch": 16,
+    "lr": 5.05e-05,
+    "train_loss": 0.5682916087197138,
+    "train_acc": 0.8178845286423094,
+    "val_loss": 0.6209135725103075,
+    "val_acc": 0.8029312288613303,
+    "val_referable_acc": 0.9244644870349493,
+    "val_any_dr_acc": 0.8774520856820744,
+    "val_severe_or_pdr_acc": 0.9574971815107103,
+    "val_qwk": 0.7954055446182169,
+    "val_referable_auc": 0.9493490659370094,
+    "val_any_dr_auc": 0.9210591320794231,
+    "val_severe_or_pdr_auc": 0.9754178512054537
+  },
+  {
+    "epoch": 17,
+    "lr": 4.532584106825115e-05,
+    "train_loss": 0.5481052464214488,
+    "train_acc": 0.8168978349120433,
+    "val_loss": 0.635486727247378,
+    "val_acc": 0.7961668545659526,
+    "val_referable_acc": 0.9253664036076663,
+    "val_any_dr_acc": 0.867869222096956,
+    "val_severe_or_pdr_acc": 0.9629650507328072,
+    "val_qwk": 0.7962354701827697,
+    "val_referable_auc": 0.9528051854428554,
+    "val_any_dr_auc": 0.9221625944032146,
+    "val_severe_or_pdr_auc": 0.9746945132924331
+  }
+]

runs/eyepacs_dr/inception_v3_fold3/best_model_only.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:859c08cfee33d0876f0715e6243007351c59318e48cf1ee05e03073b1b8dd28b
+size 89735243

runs/eyepacs_dr/inception_v3_fold3/history.json

@@ -0,0 +1,257 @@
+[
+  {
+    "epoch": 1,
+    "lr": 0.0001,
+    "train_loss": 1.2025198198192872,
+    "train_acc": 0.5520410464591791,
+    "val_loss": 0.8228783474162036,
+    "val_acc": 0.7453776775648252,
+    "val_referable_acc": 0.8989289740698986,
+    "val_any_dr_acc": 0.8471251409244644,
+    "val_severe_or_pdr_acc": 0.9259301014656144,
+    "val_qwk": 0.6898827561312655,
+    "val_referable_auc": 0.9175911681283208,
+    "val_any_dr_auc": 0.8747995817301016,
+    "val_severe_or_pdr_auc": 0.9673576416115902
+  },
+  {
+    "epoch": 2,
+    "lr": 9.972883382072954e-05,
+    "train_loss": 1.0339324369347735,
+    "train_acc": 0.6820308976093821,
+    "val_loss": 0.8109341154641471,
+    "val_acc": 0.7558624577226607,
+    "val_referable_acc": 0.9067080045095829,
+    "val_any_dr_acc": 0.8419954904171364,
+    "val_severe_or_pdr_acc": 0.9482525366403608,
+    "val_qwk": 0.7271704083716478,
+    "val_referable_auc": 0.9356385507586122,
+    "val_any_dr_auc": 0.9036777524528425,
+    "val_severe_or_pdr_auc": 0.9724214181695979
+  },
+  {
+    "epoch": 3,
+    "lr": 9.891830623632339e-05,
+    "train_loss": 0.9782092773704633,
+    "train_acc": 0.7262629679747407,
+    "val_loss": 0.7510695437567881,
+    "val_acc": 0.7797632468996618,
+    "val_referable_acc": 0.9089627959413754,
+    "val_any_dr_acc": 0.8714205186020293,
+    "val_severe_or_pdr_acc": 0.947576099210823,
+    "val_qwk": 0.7372795022381535,
+    "val_referable_auc": 0.9319354956337893,
+    "val_any_dr_auc": 0.9054813371565816,
+    "val_severe_or_pdr_auc": 0.9716824987864531
+  },
+  {
+    "epoch": 4,
+    "lr": 9.757729755661011e-05,
+    "train_loss": 0.9379007722753956,
+    "train_acc": 0.7525090211998195,
+    "val_loss": 0.6549568566085252,
+    "val_acc": 0.8064825253664036,
+    "val_referable_acc": 0.9164599774520856,
+    "val_any_dr_acc": 0.8899661781285231,
+    "val_severe_or_pdr_acc": 0.9606538895152198,
+    "val_qwk": 0.7948299036997162,
+    "val_referable_auc": 0.9453975533926049,
+    "val_any_dr_auc": 0.9143007050135201,
+    "val_severe_or_pdr_auc": 0.9740853216832828
+  },
+  {
+    "epoch": 5,
+    "lr": 9.572050015330873e-05,
+    "train_loss": 0.8938556916954606,
+    "train_acc": 0.7624464366260713,
+    "val_loss": 0.7379223013004832,
+    "val_acc": 0.7736753100338218,
+    "val_referable_acc": 0.9153325817361894,
+    "val_any_dr_acc": 0.8563697857948139,
+    "val_severe_or_pdr_acc": 0.9559188275084555,
+    "val_qwk": 0.7567080724224234,
+    "val_referable_auc": 0.936530104661968,
+    "val_any_dr_auc": 0.9078175951114706,
+    "val_severe_or_pdr_auc": 0.9719054927000486
+  },
+  {
+    "epoch": 6,
+    "lr": 9.336825748732972e-05,
+    "train_loss": 0.871171380775062,
+    "train_acc": 0.7707064727108706,
+    "val_loss": 0.7070721405737833,
+    "val_acc": 0.7897406989853438,
+    "val_referable_acc": 0.9234498308906426,
+    "val_any_dr_acc": 0.8689966178128523,
+    "val_severe_or_pdr_acc": 0.9564261555806088,
+    "val_qwk": 0.7851643398048448,
+    "val_referable_auc": 0.947155445348272,
+    "val_any_dr_auc": 0.9142982950600038,
+    "val_severe_or_pdr_auc": 0.9759564243306822
+  },
+  {
+    "epoch": 7,
+    "lr": 9.05463412215599e-05,
+    "train_loss": 0.8448774115319826,
+    "train_acc": 0.7775851375732973,
+    "val_loss": 0.679549956227639,
+    "val_acc": 0.8164036076662908,
+    "val_referable_acc": 0.924520856820744,
+    "val_any_dr_acc": 0.8813416009019166,
+    "val_severe_or_pdr_acc": 0.9644870349492672,
+    "val_qwk": 0.7821747923185505,
+    "val_referable_auc": 0.9481949654990761,
+    "val_any_dr_auc": 0.9170575366190394,
+    "val_severe_or_pdr_auc": 0.9746656584892275
+  },
+  {
+    "epoch": 8,
+    "lr": 8.728566886113101e-05,
+    "train_loss": 0.8195717033094579,
+    "train_acc": 0.7809680875056383,
+    "val_loss": 0.6137274920604409,
+    "val_acc": 0.809413754227734,
+    "val_referable_acc": 0.9208004509582863,
+    "val_any_dr_acc": 0.8852311161217588,
+    "val_severe_or_pdr_acc": 0.9581172491544532,
+    "val_qwk": 0.7956730170227315,
+    "val_referable_auc": 0.9454241231831684,
+    "val_any_dr_auc": 0.9121724219624374,
+    "val_severe_or_pdr_auc": 0.9762521190396176
+  },
+  {
+    "epoch": 9,
+    "lr": 8.362196501476347e-05,
+    "train_loss": 0.7902204092351713,
+    "train_acc": 0.783026048714479,
+    "val_loss": 0.734050494479488,
+    "val_acc": 0.7920518602029313,
+    "val_referable_acc": 0.9162908680947013,
+    "val_any_dr_acc": 0.8687147688838782,
+    "val_severe_or_pdr_acc": 0.9494926719278467,
+    "val_qwk": 0.7573945822492804,
+    "val_referable_auc": 0.9479569164636216,
+    "val_any_dr_auc": 0.9187071783937456,
+    "val_severe_or_pdr_auc": 0.9708768529927934
+  },
+  {
+    "epoch": 10,
+    "lr": 7.959536998847741e-05,
+    "train_loss": 0.7650700230210227,
+    "train_acc": 0.7899188092016238,
+    "val_loss": 0.6066389189766386,
+    "val_acc": 0.8162908680947012,
+    "val_referable_acc": 0.9243517474633597,
+    "val_any_dr_acc": 0.8935174746335964,
+    "val_severe_or_pdr_acc": 0.9520293122886133,
+    "val_qwk": 0.7954633767456802,
+    "val_referable_auc": 0.9486835951455344,
+    "val_any_dr_auc": 0.9155345767059612,
+    "val_severe_or_pdr_auc": 0.9757451178074008
+  },
+  {
+    "epoch": 11,
+    "lr": 7.524999999999999e-05,
+    "train_loss": 0.7395555126368596,
+    "train_acc": 0.7941756878664863,
+    "val_loss": 0.6811727064572435,
+    "val_acc": 0.7918827508455468,
+    "val_referable_acc": 0.9159526493799324,
+    "val_any_dr_acc": 0.8719278466741827,
+    "val_severe_or_pdr_acc": 0.9613866967305524,
+    "val_qwk": 0.7880716708685575,
+    "val_referable_auc": 0.9474283812313362,
+    "val_any_dr_auc": 0.9180301775196268,
+    "val_severe_or_pdr_auc": 0.9750599305477764
+  },
+  {
+    "epoch": 12,
+    "lr": 7.06334638322521e-05,
+    "train_loss": 0.7014671185355924,
+    "train_acc": 0.8014208389715832,
+    "val_loss": 0.6409604030639235,
+    "val_acc": 0.8064261555806088,
+    "val_referable_acc": 0.9247463359639233,
+    "val_any_dr_acc": 0.8740698985343855,
+    "val_severe_or_pdr_acc": 0.9613303269447576,
+    "val_qwk": 0.7936155738468372,
+    "val_referable_auc": 0.9497614124427368,
+    "val_any_dr_auc": 0.9194105335392007,
+    "val_severe_or_pdr_auc": 0.9763317650573168
+  },
+  {
+    "epoch": 13,
+    "lr": 6.579634122155988e-05,
+    "train_loss": 0.6744532153702664,
+    "train_acc": 0.801547699594046,
+    "val_loss": 0.6877641824616924,
+    "val_acc": 0.788782412626832,
+    "val_referable_acc": 0.9089064261555806,
+    "val_any_dr_acc": 0.8720405862457723,
+    "val_severe_or_pdr_acc": 0.9422209695603156,
+    "val_qwk": 0.739571072166862,
+    "val_referable_auc": 0.9406614118746931,
+    "val_any_dr_auc": 0.9148891339689075,
+    "val_severe_or_pdr_auc": 0.9710664650311789
+  },
+  {
+    "epoch": 14,
+    "lr": 6.079162869547907e-05,
+    "train_loss": 0.6426656583326595,
+    "train_acc": 0.8055226657645467,
+    "val_loss": 0.6913967782104432,
+    "val_acc": 0.7749718151071026,
+    "val_referable_acc": 0.9171364148816235,
+    "val_any_dr_acc": 0.8547350620067644,
+    "val_severe_or_pdr_acc": 0.9571025930101466,
+    "val_qwk": 0.7778506643992253,
+    "val_referable_auc": 0.943374991710938,
+    "val_any_dr_auc": 0.9158870344500813,
+    "val_severe_or_pdr_auc": 0.9749824502445763
+  },
+  {
+    "epoch": 15,
+    "lr": 5.567415893174884e-05,
+    "train_loss": 0.6071117940986,
+    "train_acc": 0.8086659900766802,
+    "val_loss": 0.682904385593053,
+    "val_acc": 0.7785794813979707,
+    "val_referable_acc": 0.9217587373167982,
+    "val_any_dr_acc": 0.8600901916572717,
+    "val_severe_or_pdr_acc": 0.9599774520856821,
+    "val_qwk": 0.7914131533126754,
+    "val_referable_auc": 0.9482813427683984,
+    "val_any_dr_auc": 0.9183545981096161,
+    "val_severe_or_pdr_auc": 0.9763147380605655
+  },
+  {
+    "epoch": 16,
+    "lr": 5.05e-05,
+    "train_loss": 0.5828789531055419,
+    "train_acc": 0.8125140956247181,
+    "val_loss": 0.674042572795068,
+    "val_acc": 0.7829199549041713,
+    "val_referable_acc": 0.922435174746336,
+    "val_any_dr_acc": 0.8550732807215332,
+    "val_severe_or_pdr_acc": 0.9631905298759865,
+    "val_qwk": 0.7885094124571328,
+    "val_referable_auc": 0.9481833297632086,
+    "val_any_dr_auc": 0.9190702399333383,
+    "val_severe_or_pdr_auc": 0.9758976139800606
+  },
+  {
+    "epoch": 17,
+    "lr": 4.532584106825115e-05,
+    "train_loss": 0.543698809546934,
+    "train_acc": 0.8226347541723049,
+    "val_loss": 0.5916262666832366,
+    "val_acc": 0.8156708004509583,
+    "val_referable_acc": 0.9244644870349493,
+    "val_any_dr_acc": 0.8904735062006764,
+    "val_severe_or_pdr_acc": 0.9613303269447576,
+    "val_qwk": 0.8081824267323067,
+    "val_referable_auc": 0.9482310637662554,
+    "val_any_dr_auc": 0.9186220702726107,
+    "val_severe_or_pdr_auc": 0.9764491990590344
+  }
+]

runs/eyepacs_dr/inception_v3_fold4/best_model_only.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98ff44110cf6b82ea97f53048fdb966eab3a733f5ddf8131f388236900d311ac
+size 89735243

runs/eyepacs_dr/inception_v3_fold4/history.json

@@ -0,0 +1,287 @@
+[
+  {
+    "epoch": 1,
+    "lr": 0.0001,
+    "train_loss": 1.2001196421585376,
+    "train_acc": 0.5799503834009924,
+    "val_loss": 0.7569317756537789,
+    "val_acc": 0.788782412626832,
+    "val_referable_acc": 0.9088500563697858,
+    "val_any_dr_acc": 0.8717587373167982,
+    "val_severe_or_pdr_acc": 0.9549605411499437,
+    "val_qwk": 0.7429282333731377,
+    "val_referable_auc": 0.9194775303027065,
+    "val_any_dr_auc": 0.8871391804338257,
+    "val_severe_or_pdr_auc": 0.9680421111259949
+  },
+  {
+    "epoch": 2,
+    "lr": 9.972883382072954e-05,
+    "train_loss": 1.0279213763810409,
+    "train_acc": 0.6919119305367614,
+    "val_loss": 0.8218129052519126,
+    "val_acc": 0.7131905298759865,
+    "val_referable_acc": 0.9132468996617813,
+    "val_any_dr_acc": 0.8071589627959413,
+    "val_severe_or_pdr_acc": 0.9501691093573844,
+    "val_qwk": 0.7225971569447935,
+    "val_referable_auc": 0.9308688716088045,
+    "val_any_dr_auc": 0.9059231844560037,
+    "val_severe_or_pdr_auc": 0.973083919091364
+  },
+  {
+    "epoch": 3,
+    "lr": 9.891830623632339e-05,
+    "train_loss": 0.9740518329914594,
+    "train_acc": 0.7313937753721245,
+    "val_loss": 0.6883974176920791,
+    "val_acc": 0.797294250281849,
+    "val_referable_acc": 0.9175310033821872,
+    "val_any_dr_acc": 0.8841037204058625,
+    "val_severe_or_pdr_acc": 0.943630214205186,
+    "val_qwk": 0.756051220656397,
+    "val_referable_auc": 0.9364977917175292,
+    "val_any_dr_auc": 0.914930932335793,
+    "val_severe_or_pdr_auc": 0.9724510492530263
+  },
+  {
+    "epoch": 4,
+    "lr": 9.757729755661011e-05,
+    "train_loss": 0.9428328731385878,
+    "train_acc": 0.749351601262968,
+    "val_loss": 0.7232750525065984,
+    "val_acc": 0.8005073280721533,
+    "val_referable_acc": 0.917869222096956,
+    "val_any_dr_acc": 0.8906989853438557,
+    "val_severe_or_pdr_acc": 0.9491544532130778,
+    "val_qwk": 0.783084663770558,
+    "val_referable_auc": 0.9426302409992056,
+    "val_any_dr_auc": 0.9197314348315854,
+    "val_severe_or_pdr_auc": 0.9738521022661843
+  },
+  {
+    "epoch": 5,
+    "lr": 9.572050015330873e-05,
+    "train_loss": 0.9063401475219399,
+    "train_acc": 0.7640533378439333,
+    "val_loss": 0.6571064746366413,
+    "val_acc": 0.8170800450958287,
+    "val_referable_acc": 0.9222660653889515,
+    "val_any_dr_acc": 0.8917136414881623,
+    "val_severe_or_pdr_acc": 0.9569898534385569,
+    "val_qwk": 0.788183818867606,
+    "val_referable_auc": 0.9435813278531469,
+    "val_any_dr_auc": 0.9210081541524229,
+    "val_severe_or_pdr_auc": 0.9748177290801543
+  },
+  {
+    "epoch": 6,
+    "lr": 9.336825748732972e-05,
+    "train_loss": 0.8696432277647611,
+    "train_acc": 0.773849797023004,
+    "val_loss": 0.7369026844235391,
+    "val_acc": 0.7794250281848929,
+    "val_referable_acc": 0.9114430665163472,
+    "val_any_dr_acc": 0.8700112739571589,
+    "val_severe_or_pdr_acc": 0.938162344983089,
+    "val_qwk": 0.7573919491497015,
+    "val_referable_auc": 0.9446331246227204,
+    "val_any_dr_auc": 0.9217323785663145,
+    "val_severe_or_pdr_auc": 0.9769722038132437
+  },
+  {
+    "epoch": 7,
+    "lr": 9.05463412215599e-05,
+    "train_loss": 0.8532237627106203,
+    "train_acc": 0.7721019395579612,
+    "val_loss": 0.714924802317829,
+    "val_acc": 0.7762119503945885,
+    "val_referable_acc": 0.9133596392333709,
+    "val_any_dr_acc": 0.8534949267192785,
+    "val_severe_or_pdr_acc": 0.9580045095828635,
+    "val_qwk": 0.770881114926211,
+    "val_referable_auc": 0.9455423195798338,
+    "val_any_dr_auc": 0.9243729038402309,
+    "val_severe_or_pdr_auc": 0.9756124975617895
+  },
+  {
+    "epoch": 8,
+    "lr": 8.728566886113101e-05,
+    "train_loss": 0.8223982596510317,
+    "train_acc": 0.7796712900315742,
+    "val_loss": 0.6834435512275008,
+    "val_acc": 0.8021984216459978,
+    "val_referable_acc": 0.9120631341600902,
+    "val_any_dr_acc": 0.8750281848928974,
+    "val_severe_or_pdr_acc": 0.9632468996617812,
+    "val_qwk": 0.7856095873155075,
+    "val_referable_auc": 0.9450883852706131,
+    "val_any_dr_auc": 0.9239819931437874,
+    "val_severe_or_pdr_auc": 0.9751521751774899
+  },
+  {
+    "epoch": 9,
+    "lr": 8.362196501476347e-05,
+    "train_loss": 0.7951097573831267,
+    "train_acc": 0.7813627649977447,
+    "val_loss": 0.6987135975444196,
+    "val_acc": 0.7952649379932356,
+    "val_referable_acc": 0.9191657271702367,
+    "val_any_dr_acc": 0.8735062006764375,
+    "val_severe_or_pdr_acc": 0.9528184892897407,
+    "val_qwk": 0.780215455176247,
+    "val_referable_auc": 0.9475252265024259,
+    "val_any_dr_auc": 0.9271016594578287,
+    "val_severe_or_pdr_auc": 0.9774892586547659
+  },
+  {
+    "epoch": 10,
+    "lr": 7.959536998847741e-05,
+    "train_loss": 0.76612451310275,
+    "train_acc": 0.7922727785295445,
+    "val_loss": 0.6806002331693922,
+    "val_acc": 0.7983089064261556,
+    "val_referable_acc": 0.9065952649379933,
+    "val_any_dr_acc": 0.879086809470124,
+    "val_severe_or_pdr_acc": 0.9450958286358512,
+    "val_qwk": 0.7577391366454651,
+    "val_referable_auc": 0.941599400380651,
+    "val_any_dr_auc": 0.9213001872922106,
+    "val_severe_or_pdr_auc": 0.9757958039866796
+  },
+  {
+    "epoch": 11,
+    "lr": 7.524999999999999e-05,
+    "train_loss": 0.7444681421923756,
+    "train_acc": 0.7926251691474966,
+    "val_loss": 0.7777549177307421,
+    "val_acc": 0.743010146561443,
+    "val_referable_acc": 0.905749718151071,
+    "val_any_dr_acc": 0.8328635851183765,
+    "val_severe_or_pdr_acc": 0.9439120631341601,
+    "val_qwk": 0.7487336930435504,
+    "val_referable_auc": 0.9446526524090157,
+    "val_any_dr_auc": 0.9286820958770503,
+    "val_severe_or_pdr_auc": 0.9766265581046116
+  },
+  {
+    "epoch": 12,
+    "lr": 7.06334638322521e-05,
+    "train_loss": 0.7086018911610329,
+    "train_acc": 0.7951341903473161,
+    "val_loss": 0.5983526295040479,
+    "val_acc": 0.8147125140924465,
+    "val_referable_acc": 0.9256482525366404,
+    "val_any_dr_acc": 0.892728297632469,
+    "val_severe_or_pdr_acc": 0.9580608793686584,
+    "val_qwk": 0.8110785114483154,
+    "val_referable_auc": 0.9486358821012248,
+    "val_any_dr_auc": 0.9289309065981717,
+    "val_severe_or_pdr_auc": 0.9764373764737954
+  },
+  {
+    "epoch": 13,
+    "lr": 6.579634122155988e-05,
+    "train_loss": 0.685486784114943,
+    "train_acc": 0.798799052774019,
+    "val_loss": 0.7036147638802598,
+    "val_acc": 0.7593573844419391,
+    "val_referable_acc": 0.9249154453213078,
+    "val_any_dr_acc": 0.8441375422773394,
+    "val_severe_or_pdr_acc": 0.9520856820744081,
+    "val_qwk": 0.7909389147960119,
+    "val_referable_auc": 0.9498735397291792,
+    "val_any_dr_auc": 0.9288593958346787,
+    "val_severe_or_pdr_auc": 0.9767621284813532
+  },
+  {
+    "epoch": 14,
+    "lr": 6.079162869547907e-05,
+    "train_loss": 0.6543596743878665,
+    "train_acc": 0.8101037437979252,
+    "val_loss": 0.6764660255212794,
+    "val_acc": 0.7945885005636979,
+    "val_referable_acc": 0.9212514092446449,
+    "val_any_dr_acc": 0.8766065388951522,
+    "val_severe_or_pdr_acc": 0.9523111612175874,
+    "val_qwk": 0.8004058309513633,
+    "val_referable_auc": 0.9504607404671295,
+    "val_any_dr_auc": 0.9286490352111068,
+    "val_severe_or_pdr_auc": 0.9769738194948732
+  },
+  {
+    "epoch": 15,
+    "lr": 5.567415893174884e-05,
+    "train_loss": 0.6133327330481538,
+    "train_acc": 0.8088774244474515,
+    "val_loss": 0.671032424091352,
+    "val_acc": 0.784216459977452,
+    "val_referable_acc": 0.9173055242390079,
+    "val_any_dr_acc": 0.8608229988726043,
+    "val_severe_or_pdr_acc": 0.9617812852311162,
+    "val_qwk": 0.7850222340142421,
+    "val_referable_auc": 0.9432520081634717,
+    "val_any_dr_auc": 0.9289369213684067,
+    "val_severe_or_pdr_auc": 0.9740109531464078
+  },
+  {
+    "epoch": 16,
+    "lr": 5.05e-05,
+    "train_loss": 0.5739147271398063,
+    "train_acc": 0.81670049616599,
+    "val_loss": 0.7213401265719563,
+    "val_acc": 0.7605411499436302,
+    "val_referable_acc": 0.9140360766629086,
+    "val_any_dr_acc": 0.8392897406989853,
+    "val_severe_or_pdr_acc": 0.9552987598647125,
+    "val_qwk": 0.7688554755328247,
+    "val_referable_auc": 0.9424395237007641,
+    "val_any_dr_auc": 0.9210517056966835,
+    "val_severe_or_pdr_auc": 0.9737944518080359
+  },
+  {
+    "epoch": 17,
+    "lr": 4.532584106825115e-05,
+    "train_loss": 0.5483453719564585,
+    "train_acc": 0.8217890166892197,
+    "val_loss": 0.6458704775860774,
+    "val_acc": 0.8037767756482526,
+    "val_referable_acc": 0.9226606538895152,
+    "val_any_dr_acc": 0.8786922209695603,
+    "val_severe_or_pdr_acc": 0.961837655016911,
+    "val_qwk": 0.8013663508734132,
+    "val_referable_auc": 0.9431509003462377,
+    "val_any_dr_auc": 0.9270491886099637,
+    "val_severe_or_pdr_auc": 0.9746947169560793
+  },
+  {
+    "epoch": 18,
+    "lr": 4.0208371304520894e-05,
+    "train_loss": 0.5206159053149393,
+    "train_acc": 0.8248054803788903,
+    "val_loss": 0.6574336617748257,
+    "val_acc": 0.787880496054115,
+    "val_referable_acc": 0.9196730552423901,
+    "val_any_dr_acc": 0.8589064261555807,
+    "val_severe_or_pdr_acc": 0.9645434047350621,
+    "val_qwk": 0.7916413157545019,
+    "val_referable_auc": 0.9478035943818823,
+    "val_any_dr_auc": 0.9298872303811361,
+    "val_severe_or_pdr_auc": 0.9746491841101529
+  },
+  {
+    "epoch": 19,
+    "lr": 3.520365877844009e-05,
+    "train_loss": 0.4738634637832964,
+    "train_acc": 0.8307115471357691,
+    "val_loss": 0.6353207715334457,
+    "val_acc": 0.7983089064261556,
+    "val_referable_acc": 0.9183201803833145,
+    "val_any_dr_acc": 0.8669109357384442,
+    "val_severe_or_pdr_acc": 0.9680383314543405,
+    "val_qwk": 0.7947142863535627,
+    "val_referable_auc": 0.9461027792896338,
+    "val_any_dr_auc": 0.9288580381916022,
+    "val_severe_or_pdr_auc": 0.9744999538796333
+  }
+]

train.py

@@ -0,0 +1,480 @@
+import argparse
+import json
+import random
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from augmentations import get_train_transforms, get_val_transforms
+from dataloader import EyePACSDataset
+from model import DeepSeeNet
+
+
+N_CLASSES = 5
+
+
+class AlbumentationsTransform:
+    def __init__(self, transform):
+        self.transform = transform
+
+    def __call__(self, image):
+        return self.transform(image=np.asarray(image))["image"]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Train EyePACS DR classifier.")
+
+    parser.add_argument("--root", required=True, help="EyePACS root folder.")
+    parser.add_argument("--output-dir", default="checkpoints/eyepacs_dr")
+
+    parser.add_argument("--backbone", default="inception_v3")
+    parser.add_argument("--image-size", type=int, default=1024)
+    parser.add_argument("--epochs", type=int, default=20)
+    parser.add_argument("--batch-size", type=int, default=32)
+    parser.add_argument("--num-workers", type=int, default=8)
+
+    parser.add_argument("--fold", type=int, default=0)
+    parser.add_argument("--n-folds", type=int, default=5)
+    parser.add_argument("--seed", type=int, default=42)
+
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--weight-decay", type=float, default=1e-4)
+    parser.add_argument("--no-pretrained", action="store_true")
+    parser.add_argument("--freeze-backbone", action="store_true")
+    parser.add_argument("--no-class-weights", action="store_true")
+
+    parser.add_argument("--scheduler", choices=["none", "cosine", "step"], default="cosine")
+    parser.add_argument("--min-lr", type=float, default=1e-6)
+    parser.add_argument("--step-size", type=int, default=5)
+    parser.add_argument("--gamma", type=float, default=0.5)
+
+    parser.add_argument("--amp", action="store_true")
+    parser.add_argument("--grad-clip", type=float, default=0.0)
+    parser.add_argument("--save-every", type=int, default=0)
+
+    parser.add_argument("--wandb", action="store_true")
+    parser.add_argument("--wandb-project", default="eyepacs-dr")
+
+    return parser.parse_args()
+
+
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def unwrap_logits(output):
+    if isinstance(output, (tuple, list)):
+        return output[0]
+    return output
+
+
+def get_class_weights(dataset, device):
+    labels = torch.tensor([s["label"] for s in dataset.samples], dtype=torch.long)
+    counts = torch.bincount(labels, minlength=N_CLASSES).clamp_min(1)
+    weights = counts.sum() / (N_CLASSES * counts)
+    return weights.to(device)
+
+
+def build_scheduler(optimizer, args):
+    if args.scheduler == "cosine":
+        return torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer,
+            T_max=args.epochs,
+            eta_min=args.min_lr,
+        )
+
+    if args.scheduler == "step":
+        return torch.optim.lr_scheduler.StepLR(
+            optimizer,
+            step_size=args.step_size,
+            gamma=args.gamma,
+        )
+
+    return None
+
+
+def make_loader(dataset, batch_size, num_workers, shuffle, device):
+    return DataLoader(
+        dataset,
+        batch_size=batch_size,
+        shuffle=shuffle,
+        num_workers=num_workers,
+        pin_memory=device.type == "cuda",
+        drop_last=shuffle,
+        persistent_workers=num_workers > 0,
+    )
+
+
+def train_one_epoch(
+    model,
+    loader,
+    optimizer,
+    scaler,
+    criterion,
+    device,
+    use_amp=True,
+    grad_clip=0.0,
+):
+    model.train()
+
+    total_loss = 0.0
+    total_correct = 0
+    total_samples = 0
+
+    pbar = tqdm(loader, desc="Train", leave=False)
+
+    for images, labels in pbar:
+        images = images.to(device, non_blocking=True)
+        labels = labels.to(device, non_blocking=True)
+
+        optimizer.zero_grad(set_to_none=True)
+
+        with torch.amp.autocast("cuda", enabled=use_amp and device.type == "cuda"):
+            logits = unwrap_logits(model(images))
+            loss = criterion(logits, labels)
+
+        if scaler is not None:
+            scaler.scale(loss).backward()
+
+            if grad_clip > 0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+
+            scaler.step(optimizer)
+            scaler.update()
+        else:
+            loss.backward()
+
+            if grad_clip > 0:
+                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+
+            optimizer.step()
+
+        batch_size = labels.size(0)
+        total_loss += loss.item() * batch_size
+        total_correct += (logits.argmax(dim=1) == labels).sum().item()
+        total_samples += batch_size
+
+        pbar.set_postfix(
+            loss=f"{total_loss / total_samples:.4f}",
+            acc=f"{total_correct / total_samples:.4f}",
+        )
+
+    return {
+        "loss": total_loss / total_samples,
+        "acc": total_correct / total_samples,
+    }
+
+
+@torch.no_grad()
+def evaluate(model, loader, criterion, device, use_amp=True):
+    model.eval()
+
+    total_loss = 0.0
+    total_correct = 0
+    total_samples = 0
+
+    all_labels = []
+    all_probs = []
+    all_preds = []
+
+    pbar = tqdm(loader, desc="Val", leave=False)
+
+    for images, labels in pbar:
+        images = images.to(device, non_blocking=True)
+        labels = labels.to(device, non_blocking=True)
+
+        with torch.amp.autocast("cuda", enabled=use_amp and device.type == "cuda"):
+            logits = unwrap_logits(model(images))
+            loss = criterion(logits, labels)
+
+        probs = F.softmax(logits, dim=1)
+        preds = probs.argmax(dim=1)
+
+        batch_size = labels.size(0)
+        total_loss += loss.item() * batch_size
+        total_correct += (preds == labels).sum().item()
+        total_samples += batch_size
+
+        all_labels.append(labels.detach().cpu())
+        all_probs.append(probs.detach().cpu())
+        all_preds.append(preds.detach().cpu())
+
+        pbar.set_postfix(
+            loss=f"{total_loss / total_samples:.4f}",
+            acc=f"{total_correct / total_samples:.4f}",
+        )
+
+    labels = torch.cat(all_labels).numpy()
+    probs = torch.cat(all_probs).numpy()
+    preds = torch.cat(all_preds).numpy()
+
+    metrics = {
+        "loss": total_loss / total_samples,
+        "acc": total_correct / total_samples,
+        "referable_acc": float(((labels >= 2) == (preds >= 2)).mean()),
+        "any_dr_acc": float(((labels >= 1) == (preds >= 1)).mean()),
+        "severe_or_pdr_acc": float(((labels >= 3) == (preds >= 3)).mean()),
+    }
+
+    try:
+        from sklearn.metrics import cohen_kappa_score, roc_auc_score
+
+        metrics["qwk"] = float(cohen_kappa_score(labels, preds, weights="quadratic"))
+        metrics["referable_auc"] = float(
+            roc_auc_score((labels >= 2).astype(int), probs[:, 2:].sum(axis=1))
+        )
+        metrics["any_dr_auc"] = float(
+            roc_auc_score((labels >= 1).astype(int), probs[:, 1:].sum(axis=1))
+        )
+        metrics["severe_or_pdr_auc"] = float(
+            roc_auc_score((labels >= 3).astype(int), probs[:, 3:].sum(axis=1))
+        )
+    except Exception:
+        metrics["qwk"] = float("nan")
+        metrics["referable_auc"] = float("nan")
+        metrics["any_dr_auc"] = float("nan")
+        metrics["severe_or_pdr_auc"] = float("nan")
+
+    return metrics
+
+
+def save_checkpoint(path, model, optimizer, scheduler, epoch, best_metric, args, model_only=False):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    ckpt = {
+        "epoch": epoch,
+        "model": model.state_dict(),
+        "best_metric": best_metric,
+        "args": vars(args),
+        "id_to_label": {
+            0: "no_dr",
+            1: "mild_npdr",
+            2: "moderate_npdr",
+            3: "severe_npdr",
+            4: "pdr",
+        },
+    }
+
+    if not model_only:
+        ckpt["optimizer"] = optimizer.state_dict()
+        if scheduler is not None:
+            ckpt["scheduler"] = scheduler.state_dict()
+
+    torch.save(ckpt, path)
+
+
+def main():
+    args = parse_args()
+    set_seed(args.seed)
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    use_amp = args.amp and device.type == "cuda"
+
+    train_dataset = EyePACSDataset(
+        root=args.root,
+        split="all",
+        all_mode="train",
+        transform=AlbumentationsTransform(get_train_transforms(args.image_size)),
+        seed=args.seed,
+        fold=args.fold,
+        n_folds=args.n_folds,
+    )
+
+    val_dataset = EyePACSDataset(
+        root=args.root,
+        split="all",
+        all_mode="val",
+        transform=AlbumentationsTransform(get_val_transforms(args.image_size)),
+        seed=args.seed,
+        fold=args.fold,
+        n_folds=args.n_folds,
+    )
+
+    train_loader = make_loader(
+        train_dataset,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        shuffle=True,
+        device=device,
+    )
+
+    val_loader = make_loader(
+        val_dataset,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        shuffle=False,
+        device=device,
+    )
+
+    model = DeepSeeNet(
+        n_classes=N_CLASSES,
+        backbone=args.backbone,
+        pretrained=not args.no_pretrained,
+        freeze_backbone=args.freeze_backbone,
+    ).to(device)
+
+    class_weights = None
+    if not args.no_class_weights:
+        class_weights = get_class_weights(train_dataset, device)
+
+    train_criterion = torch.nn.CrossEntropyLoss(weight=class_weights)
+    val_criterion = torch.nn.CrossEntropyLoss()
+
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=args.lr,
+        weight_decay=args.weight_decay,
+    )
+
+    scheduler = build_scheduler(optimizer, args)
+    scaler = torch.amp.GradScaler("cuda") if use_amp else None
+
+    wandb = None
+    if args.wandb:
+        import wandb
+
+        wandb.init(project=args.wandb_project, config=vars(args))
+
+    print("\nEyePACS DR training")
+    print("-------------------")
+    print(f"Device:        {device}")
+    print(f"Root:          {args.root}")
+    print(f"Output:        {output_dir}")
+    print(f"Backbone:      {args.backbone}")
+    print(f"Image size:    {args.image_size}")
+    print(f"Fold:          {args.fold}/{args.n_folds}")
+    print(f"Train samples: {len(train_dataset)}")
+    print(f"Val samples:   {len(val_dataset)}")
+    print(f"AMP:           {use_amp}")
+    print(f"Pretrained:    {not args.no_pretrained}")
+
+    if class_weights is not None:
+        print(f"Class weights: {class_weights.detach().cpu().tolist()}")
+
+    best_qwk = -float("inf")
+    history = []
+
+    for epoch in range(1, args.epochs + 1):
+        print(f"\nEpoch [{epoch:03d}/{args.epochs}]")
+
+        train_metrics = train_one_epoch(
+            model=model,
+            loader=train_loader,
+            optimizer=optimizer,
+            scaler=scaler,
+            criterion=train_criterion,
+            device=device,
+            use_amp=use_amp,
+            grad_clip=args.grad_clip,
+        )
+
+        val_metrics = evaluate(
+            model=model,
+            loader=val_loader,
+            criterion=val_criterion,
+            device=device,
+            use_amp=use_amp,
+        )
+
+        lr = optimizer.param_groups[0]["lr"]
+
+        row = {
+            "epoch": epoch,
+            "lr": lr,
+            **{f"train_{k}": v for k, v in train_metrics.items()},
+            **{f"val_{k}": v for k, v in val_metrics.items()},
+        }
+        history.append(row)
+
+        print(
+            f"lr={lr:.2e} "
+            f"train_loss={train_metrics['loss']:.4f} "
+            f"train_acc={train_metrics['acc']:.4f} "
+            f"val_loss={val_metrics['loss']:.4f} "
+            f"val_acc={val_metrics['acc']:.4f} "
+            f"val_qwk={val_metrics['qwk']:.4f} "
+            f"val_ref_auc={val_metrics['referable_auc']:.4f}"
+        )
+
+        if wandb is not None:
+            wandb.log(row)
+
+        with (output_dir / "history.json").open("w") as f:
+            json.dump(history, f, indent=2)
+
+        monitor = val_metrics["qwk"]
+        if np.isnan(monitor):
+            monitor = -val_metrics["loss"]
+
+        if monitor > best_qwk:
+            best_qwk = monitor
+
+            save_checkpoint(
+                output_dir / "best.pt",
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                epoch=epoch,
+                best_metric=best_qwk,
+                args=args,
+                model_only=False,
+            )
+
+            save_checkpoint(
+                output_dir / "best_model_only.pt",
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                epoch=epoch,
+                best_metric=best_qwk,
+                args=args,
+                model_only=True,
+            )
+
+            print(f"Saved best checkpoint: monitor={best_qwk:.4f}")
+
+        if args.save_every > 0 and epoch % args.save_every == 0:
+            save_checkpoint(
+                output_dir / f"epoch_{epoch:03d}.pt",
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                epoch=epoch,
+                best_metric=best_qwk,
+                args=args,
+                model_only=False,
+            )
+
+        if scheduler is not None:
+            scheduler.step()
+
+    save_checkpoint(
+        output_dir / "last.pt",
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        epoch=args.epochs,
+        best_metric=best_qwk,
+        args=args,
+        model_only=False,
+    )
+
+    print("\nTraining complete.")
+    print(f"Best monitor/QWK: {best_qwk:.4f}")
+    print(f"Saved to: {output_dir}")
+
+
+if __name__ == "__main__":
+    main()