code/scripts/v4_train.py

"""
V4: Segmentation-Generation Cycle Consistency Training.
Supports kvasir (binary), cvc (binary), and refuge2 (3-class).

5 conditions: no_aug, baseline, cycle, consist, cycle_consist
Each condition runs 3 seeds (42, 43, 44), 200 epochs.

Usage:
  python scripts/v4_train.py --dataset kvasir --low_data_ratio 1.0 --conditions cycle
  python scripts/v4_train.py --dataset cvc --low_data_ratio 1.0 --conditions baseline
  python scripts/v4_train.py --dataset refuge2 --low_data_ratio 1.0 --conditions cycle_consist
"""
import sys
sys.path.insert(0, "/data/sichengli/Code/PixelGen")

import argparse
import os
import json
import random
import itertools
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from PIL import Image
import torchvision.transforms as transforms
import torchvision.transforms.functional as TF
import segmentation_models_pytorch as smp

from segmentation.losses import BCEDiceLoss, CEDiceLoss
from segmentation.metrics import compute_dice_iou_binary, compute_dice_iou_multiclass, MetricTracker


# ─── Config ───────────────────────────────────────────────────────────
DATASET_CONFIGS = {
    "kvasir": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/Kvasir-SEG/Kvasir-SEG",
        "img_subdir": "images", "mask_subdir": "masks",
        "file_ext": (".jpg", ".png", ".jpeg"),
        "multi_split": False, "train_ratio": 0.9,
        "task": "binary", "num_classes": 1,
    },
    "cvc": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/CVC-ClinicDB",
        "img_subdir": "PNG/Original", "mask_subdir": "PNG/Ground Truth",
        "file_ext": (".png",),
        "multi_split": False, "train_ratio": 0.9,
        "task": "binary", "num_classes": 1,
    },
    "refuge2": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/REFUGE2",
        "splits": ["train", "val"],
        "file_ext": (".jpg", ".png", ".jpeg"),
        "mask_ext": (".bmp", ".png"),
        "multi_split": True, "val_ratio": 0.1,
        "task": "multiclass", "num_classes": 3,
        "class_mapping": {0: 0, 128: 1, 255: 2},
    },
}

WORK_DIR_BASE = "/data/sichengli/Code/PixelGen/synergy_v4_workdir"
RESOLUTION = 256
SPLIT_SEED = 42

IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD = [0.229, 0.224, 0.225]

EPOCHS = 200
BATCH_SIZE = 16
LR = 1e-4
WEIGHT_DECAY = 1e-4
LAMBDA_CYCLE = 1.0
LAMBDA_CONSIST = 1.0
CONSIST_RAMPUP = 10
SEEDS = [42, 43, 44]
ALL_CONDITIONS = ["no_aug", "baseline", "cycle", "consist", "cycle_consist"]


# ─── Mask Processing ─────────────────────────────────────────────────
def process_mask(mask_pil, task, class_mapping=None):
    """Convert PIL grayscale mask to tensor.
    Binary: [1, H, W] float {0, 1}
    Multiclass: [H, W] long {0, ..., C-1}
    """
    mask_np = np.array(mask_pil)
    if task == "binary":
        mask_np = (mask_np > 127).astype(np.float32)
        return torch.from_numpy(mask_np).unsqueeze(0)
    else:
        result = np.zeros_like(mask_np, dtype=np.int64)
        for pixel_val, class_idx in class_mapping.items():
            result[mask_np == pixel_val] = class_idx
        for pixel_val in np.unique(mask_np):
            if pixel_val not in class_mapping:
                closest = min(class_mapping.keys(), key=lambda x: abs(x - pixel_val))
                result[mask_np == pixel_val] = class_mapping[closest]
        return torch.from_numpy(result).long()


# ─── Datasets ─────────────────────────────────────────────────────────
class RealDataset(Dataset):
    """Real images + masks for supervised training. Supports all three datasets."""
    def __init__(self, dataset_name, split="train", augment=True,
                 low_data_ratio=1.0, low_data_seed=42):
        cfg = DATASET_CONFIGS[dataset_name]
        self.task = cfg["task"]
        self.class_mapping = cfg.get("class_mapping")
        self.resolution = RESOLUTION
        self.augment = augment and (split == "train")
        self.normalize = transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)

        if cfg["multi_split"]:
            all_pairs = []
            for s in cfg["splits"]:
                img_dir = os.path.join(cfg["data_root"], s, "images")
                mask_dir = os.path.join(cfg["data_root"], s, "mask")
                img_files = sorted([f for f in os.listdir(img_dir) if f.endswith(cfg["file_ext"])])
                for img_f in img_files:
                    base = os.path.splitext(img_f)[0]
                    img_path = os.path.join(img_dir, img_f)
                    for ext in cfg["mask_ext"]:
                        candidate = os.path.join(mask_dir, base + ext)
                        if os.path.exists(candidate):
                            all_pairs.append((img_path, candidate))
                            break
            random.seed(SPLIT_SEED)
            random.shuffle(all_pairs)
            split_idx = int(len(all_pairs) * (1 - cfg.get("val_ratio", 0.1)))
            self.pairs = all_pairs[:split_idx] if split == "train" else all_pairs[split_idx:]
        else:
            img_dir = os.path.join(cfg["data_root"], cfg["img_subdir"])
            mask_dir = os.path.join(cfg["data_root"], cfg["mask_subdir"])
            all_files = sorted([f for f in os.listdir(img_dir) if f.endswith(cfg["file_ext"])])
            random.seed(SPLIT_SEED)
            indices = list(range(len(all_files)))
            random.shuffle(indices)
            split_idx = int(len(indices) * cfg["train_ratio"])
            sel = indices[:split_idx] if split == "train" else indices[split_idx:]
            sel_files = [all_files[i] for i in sorted(sel)]
            self.pairs = [(os.path.join(img_dir, f), os.path.join(mask_dir, f)) for f in sel_files
                          if os.path.exists(os.path.join(mask_dir, f))]

        # Sub-sample for low-data
        if split == "train" and low_data_ratio < 1.0:
            random.seed(low_data_seed)
            n = int(len(self.pairs) * low_data_ratio)
            sub = random.sample(range(len(self.pairs)), n)
            self.pairs = [self.pairs[i] for i in sorted(sub)]

        print(f"[RealDataset-{dataset_name}] {split}: {len(self.pairs)} samples (augment={self.augment})")

    def __len__(self):
        return len(self.pairs)

    def __getitem__(self, idx):
        img_path, mask_path = self.pairs[idx]
        image = Image.open(img_path).convert("RGB")
        mask = Image.open(mask_path).convert("L")

        image = TF.resize(image, (self.resolution, self.resolution),
                          interpolation=transforms.InterpolationMode.BILINEAR)
        mask = TF.resize(mask, (self.resolution, self.resolution),
                         interpolation=transforms.InterpolationMode.NEAREST)

        if self.augment:
            if random.random() > 0.5:
                image = TF.hflip(image)
                mask = TF.hflip(mask)
            if random.random() > 0.5:
                image = TF.vflip(image)
                mask = TF.vflip(mask)
            if random.random() > 0.5:
                image = TF.adjust_brightness(image, random.uniform(0.85, 1.15))
                image = TF.adjust_contrast(image, random.uniform(0.85, 1.15))
                image = TF.adjust_saturation(image, random.uniform(0.85, 1.15))

        image_tensor = self.normalize(TF.to_tensor(image))
        mask_tensor = process_mask(mask, self.task, self.class_mapping)
        return image_tensor, mask_tensor


class GeneratedPairDataset(Dataset):
    """Load pre-generated image pairs + masks for cycle/consistency training."""
    def __init__(self, gen_dir, task="binary", class_mapping=None):
        self.gen_dir = gen_dir
        self.task = task
        self.class_mapping = class_mapping
        self.normalize = transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)

        mask_dir = os.path.join(gen_dir, "masks")
        self.indices = sorted([int(f.split(".")[0]) for f in os.listdir(mask_dir) if f.endswith(".png")])
        print(f"[GeneratedPairDataset] {len(self.indices)} triplets")

    def __len__(self):
        return len(self.indices)

    def __getitem__(self, idx):
        file_idx = self.indices[idx]
        fname = f"{file_idx:04d}.png"

        img0 = Image.open(os.path.join(self.gen_dir, "seed0", fname)).convert("RGB")
        img1 = Image.open(os.path.join(self.gen_dir, "seed1", fname)).convert("RGB")
        mask = Image.open(os.path.join(self.gen_dir, "masks", fname)).convert("L")

        if random.random() > 0.5:
            img0 = TF.hflip(img0)
            img1 = TF.hflip(img1)
            mask = TF.hflip(mask)
        if random.random() > 0.5:
            img0 = TF.vflip(img0)
            img1 = TF.vflip(img1)
            mask = TF.vflip(mask)

        img0_tensor = self.normalize(TF.to_tensor(img0))
        img1_tensor = self.normalize(TF.to_tensor(img1))
        mask_tensor = process_mask(mask, self.task, self.class_mapping)
        return img0_tensor, img1_tensor, mask_tensor


# ─── Training ─────────────────────────────────────────────────────────
def compute_metrics(logits, masks, task, num_classes):
    if task == "binary":
        return compute_dice_iou_binary(logits, masks)
    else:
        dice, iou, _, _ = compute_dice_iou_multiclass(logits, masks, num_classes)
        return dice, iou


def train_condition(condition, seed, device, dataset_name, low_data_ratio=1.0):
    cfg = DATASET_CONFIGS[dataset_name]
    task = cfg["task"]
    num_classes = cfg["num_classes"]
    work_dir = os.path.join(WORK_DIR_BASE, dataset_name)
    gen_dir = os.path.join(work_dir, "generated")

    data_tag = "full" if low_data_ratio >= 1.0 else "low"
    print(f"\n{'='*60}")
    print(f"  {dataset_name} | {condition} | seed={seed} | {data_tag}")
    print(f"{'='*60}")

    torch.manual_seed(seed)
    random.seed(seed)
    np.random.seed(seed)

    use_aug = condition != "no_aug"
    use_cycle = condition in ("cycle", "cycle_consist")
    use_consist = condition in ("consist", "cycle_consist")
    use_gen = use_cycle or use_consist

    train_dataset = RealDataset(dataset_name, "train", augment=use_aug,
                                 low_data_ratio=low_data_ratio, low_data_seed=SPLIT_SEED)
    val_dataset = RealDataset(dataset_name, "val", augment=False,
                               low_data_ratio=1.0, low_data_seed=SPLIT_SEED)

    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE,
                              shuffle=True, num_workers=4, pin_memory=True, drop_last=True)
    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE,
                            shuffle=False, num_workers=4, pin_memory=True)

    gen_loader_iter = None
    if use_gen:
        gen_dataset = GeneratedPairDataset(gen_dir, task=task,
                                            class_mapping=cfg.get("class_mapping"))
        gen_loader = DataLoader(gen_dataset, batch_size=BATCH_SIZE,
                                shuffle=True, num_workers=4, pin_memory=True, drop_last=True)
        gen_loader_iter = iter(itertools.cycle(gen_loader))

    # Model
    out_classes = 1 if task == "binary" else num_classes
    model = smp.Unet(encoder_name="resnet34", encoder_weights="imagenet",
                     in_channels=3, classes=out_classes).to(device)

    criterion = BCEDiceLoss() if task == "binary" else CEDiceLoss(num_classes=num_classes)
    mse_loss = nn.MSELoss()
    optimizer = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)

    ckpt_dir = os.path.join(work_dir, "checkpoints", f"{data_tag}_{condition}_seed{seed}")
    os.makedirs(ckpt_dir, exist_ok=True)

    best_dice = 0.0
    best_iou = 0.0

    for epoch in range(1, EPOCHS + 1):
        model.train()
        tracker = MetricTracker()
        total_loss = 0.0

        for real_imgs, real_masks in train_loader:
            real_imgs = real_imgs.to(device)
            real_masks = real_masks.to(device)

            logits = model(real_imgs)
            l_sup = criterion(logits, real_masks)
            loss = l_sup

            if use_gen:
                gen_img0, gen_img1, gen_mask = next(gen_loader_iter)
                gen_img0 = gen_img0.to(device)
                gen_img1 = gen_img1.to(device)
                gen_mask = gen_mask.to(device)

                pred0 = model(gen_img0)
                pred1 = model(gen_img1)

                if use_cycle:
                    l_cycle = 0.5 * (criterion(pred0, gen_mask) + criterion(pred1, gen_mask))
                    loss = loss + LAMBDA_CYCLE * l_cycle

                if use_consist:
                    rampup = min(1.0, epoch / CONSIST_RAMPUP)
                    if task == "binary":
                        l_consist = mse_loss(torch.sigmoid(pred0), torch.sigmoid(pred1))
                    else:
                        l_consist = mse_loss(F.softmax(pred0, dim=1), F.softmax(pred1, dim=1))
                    loss = loss + LAMBDA_CONSIST * rampup * l_consist

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            total_loss += loss.item() * real_imgs.size(0)
            with torch.no_grad():
                dice, iou = compute_metrics(logits, real_masks, task, num_classes)
            tracker.update(dice, iou, real_imgs.size(0))

        scheduler.step()

        val_loss, val_dice, val_iou = validate(model, val_loader, criterion, device, task, num_classes)

        if val_dice > best_dice:
            best_dice = val_dice
            best_iou = val_iou
            torch.save({
                "epoch": epoch,
                "model_state_dict": model.state_dict(),
                "best_dice": best_dice,
                "best_iou": best_iou,
                "condition": condition,
                "seed": seed,
                "dataset": dataset_name,
                "task": task,
                "num_classes": num_classes,
            }, os.path.join(ckpt_dir, "best.pth"))

        if epoch % 20 == 0 or epoch == 1:
            avg_loss = total_loss / max(len(train_loader.dataset), 1)
            lr = optimizer.param_groups[0]["lr"]
            print(f"  Epoch {epoch:>3d}/{EPOCHS} | "
                  f"Loss: {avg_loss:.4f} Dice: {tracker.avg_dice:.4f} | "
                  f"Val Dice: {val_dice:.4f} IoU: {val_iou:.4f} | "
                  f"Best: {best_dice:.4f} | LR: {lr:.2e}")

    print(f"  -> {condition} seed={seed}: Best Val Dice={best_dice:.4f}, IoU={best_iou:.4f}")
    return best_dice, best_iou


@torch.no_grad()
def validate(model, loader, criterion, device, task, num_classes):
    model.eval()
    tracker = MetricTracker()
    total_loss = 0.0

    for images, masks in loader:
        images = images.to(device)
        masks = masks.to(device)
        logits = model(images)
        loss = criterion(logits, masks)
        dice, iou = compute_metrics(logits, masks, task, num_classes)
        total_loss += loss.item() * images.size(0)
        tracker.update(dice, iou, images.size(0))

    return total_loss / max(len(loader.dataset), 1), tracker.avg_dice, tracker.avg_iou


# ─── Main ─────────────────────────────────────────────────────────────
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset", type=str, required=True, choices=["kvasir", "cvc", "refuge2"])
    parser.add_argument("--conditions", nargs="+", default=ALL_CONDITIONS, choices=ALL_CONDITIONS)
    parser.add_argument("--low_data_ratio", type=float, default=1.0)
    parser.add_argument("--gpu", type=int, default=0)
    args = parser.parse_args()

    device = torch.device(f"cuda:{args.gpu}")
    work_dir = os.path.join(WORK_DIR_BASE, args.dataset)
    os.makedirs(work_dir, exist_ok=True)

    data_tag = "full" if args.low_data_ratio >= 1.0 else "low"
    print(f"\n  Dataset: {args.dataset} | Data: {data_tag} (ratio={args.low_data_ratio})\n")

    results = {}
    for condition in args.conditions:
        cond_results = []
        for seed in SEEDS:
            best_dice, best_iou = train_condition(
                condition, seed, device, args.dataset, args.low_data_ratio)
            cond_results.append({"seed": seed, "dice": best_dice, "iou": best_iou})

        dices = [r["dice"] for r in cond_results]
        ious = [r["iou"] for r in cond_results]
        key = f"{data_tag}_{condition}"
        results[key] = {
            "runs": cond_results,
            "mean_dice": float(np.mean(dices)),
            "std_dice": float(np.std(dices)),
            "mean_iou": float(np.mean(ious)),
            "std_iou": float(np.std(ious)),
        }

    results_path = os.path.join(work_dir, "downstream_results.json")
    if os.path.exists(results_path):
        with open(results_path, "r") as f:
            existing = json.load(f)
        existing.update(results)
        results = existing
    with open(results_path, "w") as f:
        json.dump(results, f, indent=2)

    # Summary
    print(f"\n{'='*75}")
    print(f"  V4 RESULTS: {args.dataset} ({data_tag})")
    print(f"{'='*75}")
    print(f"{'Condition':<22s} | {'Dice (mean+/-std)':>20s} | {'IoU (mean+/-std)':>20s} | {'vs baseline':>12s}")
    print("-" * 80)

    bl_key = f"{data_tag}_baseline"
    bl_dice = results.get(bl_key, {}).get("mean_dice", None)
    for cond in ALL_CONDITIONS:
        key = f"{data_tag}_{cond}"
        if key not in results:
            continue
        r = results[key]
        d_str = f"{r['mean_dice']:.4f} +/- {r['std_dice']:.4f}"
        i_str = f"{r['mean_iou']:.4f} +/- {r['std_iou']:.4f}"
        delta = f"{r['mean_dice'] - bl_dice:+.4f}" if bl_dice and cond != "baseline" else "-"
        print(f"{key:<22s} | {d_str:>20s} | {i_str:>20s} | {delta:>12s}")
    print("=" * 80)


if __name__ == "__main__":
    main()