training_scripts/train_blur_brats_3.py

#!/usr/bin/env python3
"""
train_conditional_final.py — Robust conditional trainer (drop-in)

Changes made:
- ALWAYS skip loading optimizer state on resume (prints a clear message).
- Fixed safe_torch_load (removed nonexistent weights_only kwarg).
- Use the single `device` variable everywhere (no repeated get_device() calls).
- More robust EMA sampling/load logic.
- DEFAULT_VAL_SAMPLE_STEPS set to 1000 (can still be overridden by CLI).
- Small defensive logging & comments.
"""

import argparse
import math
import os
import random
import signal
from pathlib import Path
from typing import Dict, Optional

import numpy as np
from PIL import Image, ImageFilter

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

from tqdm import tqdm

# --------------------------
# Default config (will be overridden by CLI)
# --------------------------
DEFAULT_BASE_DIR = Path("/Users/arvindarya/Documents/compression/train")
DEFAULT_IMAGE_SIZE = 240
DEFAULT_BATCH_SIZE = 8
DEFAULT_NUM_WORKERS = 2
DEFAULT_TIMESTEPS = 1000
DEFAULT_TOTAL_STEPS = 600000
DEFAULT_LR = 1e-4
DEFAULT_SAVE_EVERY = 2000
DEFAULT_SAMPLE_EVERY = 1000
DEFAULT_EMA_DECAY = 0.9999
DEFAULT_VAL_SAMPLE_STEPS = 1000

# --------------------------
# Helpers: device, atomic save, safe load, remapper
# --------------------------
def get_device():
    # prefer mps if available (mac), else cuda, else cpu
    if getattr(torch.backends, "mps", None) is not None and getattr(torch.backends, "mps", None).is_available() and getattr(torch.backends, "mps", None).is_built():
        return torch.device("mps")
    if torch.cuda.is_available():
        return torch.device("cuda")
    return torch.device("cpu")

def atomic_save(obj, path: Path):
    tmp = path.with_suffix(".tmp")
    torch.save(obj, tmp)
    tmp.replace(path)

def safe_torch_load(path: Path, map_location):
    """
    Robust local load. If it fails, raise with a clear message.
    (Don't attempt unsupported torch.load kwargs.)
    """
    try:
        return torch.load(path, map_location=map_location)
    except Exception as e:
        raise RuntimeError(f"Failed to load checkpoint {path}: {e}")

def remap_checkpoint_to_model(checkpoint_sd: Dict[str, torch.Tensor], model: torch.nn.Module) -> Dict[str, torch.Tensor]:
    """
    Remap checkpoint state-dict keys to match the model's key naming for res/res_conv.
    """
    ck_keys = set(checkpoint_sd.keys())
    model_keys = set(model.state_dict().keys())

    has_ck_res_conv = any(".res_conv." in k for k in ck_keys)
    has_ck_res = any(".res." in k for k in ck_keys)
    has_mod_res_conv = any(".res_conv." in k for k in model_keys)
    has_mod_res = any(".res." in k for k in model_keys)

    # checkpoint uses res_conv, model expects res
    if has_ck_res_conv and has_mod_res and not has_mod_res_conv:
        return {k.replace(".res_conv.", ".res."): v for k, v in checkpoint_sd.items()}

    # checkpoint uses res, model expects res_conv
    if has_ck_res and has_mod_res_conv and not has_mod_res:
        return {k.replace(".res.", ".res_conv."): v for k, v in checkpoint_sd.items()}

    # otherwise return unchanged
    return checkpoint_sd

# --------------------------
# Dataset: returns (x0, cond_blur)
# --------------------------
class ConditionalMRI(Dataset):
    def __init__(self, list_path: str, image_size: int = DEFAULT_IMAGE_SIZE, blur_radius: float = 3.0):
        p = Path(list_path)
        if not p.exists():
            raise RuntimeError(f"Train list not found: {p}")
        with open(p, "r") as f:
            lines = [l.strip() for l in f.readlines() if l.strip()]
        if not lines:
            raise RuntimeError(f"No image paths found in {p}")
        self.paths = [Path(x) for x in lines]
        self.image_size = image_size
        self.blur_radius = blur_radius
        print(f"[Dataset] {len(self.paths)} items; blur radius {self.blur_radius}")

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

    def __getitem__(self, idx):
        p = self.paths[idx]
        img = Image.open(p).convert("L").resize((self.image_size, self.image_size))
        arr = np.array(img, dtype=np.float32) / 255.0
        x0 = arr * 2.0 - 1.0
        blurred = img.filter(ImageFilter.GaussianBlur(radius=self.blur_radius))
        b_arr = np.array(blurred, dtype=np.float32) / 255.0
        b = b_arr * 2.0 - 1.0
        x0_t = torch.from_numpy(x0).unsqueeze(0).float()
        b_t = torch.from_numpy(b).unsqueeze(0).float()
        return x0_t, b_t

# --------------------------
# Model: UNet conditional
# --------------------------
class SinusoidalTimeEmbedding(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.dim = dim
    def forward(self, t):
        device = t.device
        half = self.dim // 2
        emb = math.log(10000) / (half - 1)
        emb = torch.exp(torch.arange(half, device=device) * -emb)
        emb = t.float().unsqueeze(1) * emb.unsqueeze(0)
        return torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)

class ResBlock(nn.Module):
    # keep attribute name res_conv to match both variants (remapper handles differences)
    def __init__(self, in_ch, out_ch, time_dim):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, padding=1)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, padding=1)
        self.time_mlp = nn.Linear(time_dim, out_ch)
        self.act = nn.SiLU()
        self.res_conv = nn.Conv2d(in_ch, out_ch, 1) if in_ch != out_ch else nn.Identity()
    def forward(self, x, t_emb):
        h = self.act(self.conv1(x))
        h = h + self.time_mlp(t_emb).unsqueeze(-1).unsqueeze(-1)
        h = self.conv2(h)
        return self.act(h + self.res_conv(x))

class UNetCond(nn.Module):
    def __init__(self, in_ch=2, base=64, time_dim=256):
        super().__init__()
        self.time_mlp = nn.Sequential(
            SinusoidalTimeEmbedding(time_dim),
            nn.Linear(time_dim, time_dim * 2),
            nn.SiLU(),
            nn.Linear(time_dim * 2, time_dim),
        )
        # small condition projection to strengthen conditioning at early layers
        self.cond_proj = nn.Sequential(
            nn.Conv2d(1, base, 3, padding=1),
            nn.SiLU(),
            nn.Conv2d(base, base, 3, padding=1),
        )

        self.down1 = ResBlock(in_ch, base, time_dim)
        self.down2 = ResBlock(base, base * 2, time_dim)
        self.down3 = ResBlock(base * 2, base * 4, time_dim)
        self.pool = nn.AvgPool2d(2)
        self.bot = ResBlock(base * 4, base * 4, time_dim)
        self.up3 = ResBlock(base * 4 + base * 4, base * 2, time_dim)
        self.up2 = ResBlock(base * 2 + base * 2, base, time_dim)
        self.up1 = ResBlock(base + base, base, time_dim)
        self.upsample = nn.Upsample(scale_factor=2, mode="bilinear", align_corners=False)
        self.final = nn.Conv2d(base, 1, 1)

    def forward(self, noisy_and_cond, t):
        device = noisy_and_cond.device
        t_emb = self.time_mlp(t)

        noisy = noisy_and_cond[:, :1, ...]
        cond = noisy_and_cond[:, 1:, ...]
        cond_feat = self.cond_proj(cond)

        d1 = self.down1(torch.cat([noisy, cond], dim=1), t_emb)
        try:
            d1 = d1 + cond_feat
        except Exception:
            pass

        d2 = self.down2(self.pool(d1), t_emb)
        d3 = self.down3(self.pool(d2), t_emb)
        b = self.bot(self.pool(d3), t_emb)
        u3 = self.upsample(b); u3 = torch.cat([u3, d3], dim=1); u3 = self.up3(u3, t_emb)
        u2 = self.upsample(u3); u2 = torch.cat([u2, d2], dim=1); u2 = self.up2(u2, t_emb)
        u1 = self.upsample(u2); u1 = torch.cat([u1, d1], dim=1); u1 = self.up1(u1, t_emb)
        return self.final(u1)

# --------------------------
# Diffusion utils
# --------------------------
def make_beta_schedule(timesteps, start=1e-4, end=0.02):
    return torch.linspace(start, end, timesteps)

class Diffusion(nn.Module):
    def __init__(self, timesteps=1000, device="cpu"):
        super().__init__()
        self.timesteps = timesteps
        betas = make_beta_schedule(timesteps).to(device)
        alphas = 1.0 - betas
        alphas_cumprod = torch.cumprod(alphas, dim=0)
        alphas_cumprod_prev = torch.cat([torch.tensor([1.0], device=device), alphas_cumprod[:-1]], dim=0)
        self.register_buffer("betas", betas)
        self.register_buffer("alphas", alphas)
        self.register_buffer("alphas_cumprod", alphas_cumprod)
        self.register_buffer("alphas_cumprod_prev", alphas_cumprod_prev)

    def q_sample(self, x0, t, noise=None):
        if noise is None: noise = torch.randn_like(x0)
        ac = self.alphas_cumprod[t].view(-1,1,1,1)
        return torch.sqrt(ac) * x0 + torch.sqrt(1.0 - ac) * noise

    def p_losses(self, model, x0, cond, t):
        noise = torch.randn_like(x0)
        x_t = self.q_sample(x0, t, noise)
        inp = torch.cat([x_t, cond], dim=1)
        noise_pred = model(inp, t)
        return F.mse_loss(noise_pred, noise)

    @torch.no_grad()
    def p_sample(self, model, x_t, cond, t):
        betas_t = self.betas[t].view(-1,1,1,1)
        alphas_t = (1.0 - betas_t)
        alphas_cumprod_t = self.alphas_cumprod[t].view(-1,1,1,1)
        eps_theta = model(torch.cat([x_t, cond], dim=1), t)
        coef1 = 1.0 / torch.sqrt(alphas_t)
        coef2 = (1.0 - alphas_t) / torch.sqrt(1.0 - alphas_cumprod_t)
        mean = coef1 * (x_t - coef2 * eps_theta)
        noise = torch.randn_like(x_t)
        mask = (t > 0).float().view(-1,1,1,1)
        sigma = torch.sqrt(betas_t)
        return mean + mask * sigma * noise

    @torch.no_grad()
    def sample_conditional(self, model, cond, device, start_t=None, num_steps=None):
        model.eval()
        if start_t is None: start_t = self.timesteps - 1
        if num_steps is None: num_steps = start_t + 1
        B = cond.shape[0]
        x_t = torch.randn((B,1,cond.shape[2],cond.shape[3]), device=device)
        t_values = list(range(start_t, -1, -1))
        if num_steps < len(t_values):
            idxs = np.linspace(0, len(t_values)-1, num_steps).astype(int)
            t_values = [t_values[i] for i in idxs]
        for t_scalar in t_values:
            t_batch = torch.tensor([t_scalar]*B, device=device).long()
            x_t = self.p_sample(model, x_t, cond, t_batch)
        return x_t

# --------------------------
# EMA helper
# --------------------------
class EMA:
    def __init__(self, net: nn.Module, decay: float = DEFAULT_EMA_DECAY):
        self.decay = decay
        self.shadow = {k: v.clone().detach() for k, v in net.state_dict().items()}

    def update(self, net: nn.Module):
        for k, v in net.state_dict().items():
            if k in self.shadow:
                self.shadow[k].mul_(self.decay).add_(v.detach(), alpha=1.0 - self.decay)
            else:
                self.shadow[k] = v.clone().detach()

    def to_state_dict(self):
        return {k: v.clone().cpu() for k, v in self.shadow.items()}

    def load_state_dict(self, sd: Dict[str, torch.Tensor]):
        self.shadow = {k: v.clone().detach() for k, v in sd.items()}

# --------------------------
# Image grid save
# --------------------------
def save_grid(tensor: torch.Tensor, path: Path, nrow: int = 2):
    tensor = tensor.detach().cpu()
    arr = ((tensor + 1.0) / 2.0).clamp(0,1).numpy() * 255.0
    arr = arr.astype(np.uint8)
    B,C,H,W = arr.shape
    ncol = math.ceil(B / nrow)
    grid = Image.new("L", (W * ncol, H * nrow))
    idx = 0
    for r in range(nrow):
        for c in range(ncol):
            if idx >= B: break
            img = Image.fromarray(arr[idx,0])
            grid.paste(img, (c*W, r*H))
            idx += 1
    path.parent.mkdir(parents=True, exist_ok=True)
    grid.save(path)
    print(f"[SAVE] image saved: {path}")

# --------------------------
# Trainer (main)
# --------------------------
def train(
    base_dir: str,
    train_list: Optional[str] = None,
    image_size: int = DEFAULT_IMAGE_SIZE,
    batch_size: int = DEFAULT_BATCH_SIZE,
    num_workers: int = DEFAULT_NUM_WORKERS,
    timesteps: int = DEFAULT_TIMESTEPS,
    total_steps: int = DEFAULT_TOTAL_STEPS,
    lr: float = DEFAULT_LR,
    base_channels: int = 64,
    save_every: int = DEFAULT_SAVE_EVERY,
    sample_every: int = DEFAULT_SAMPLE_EVERY,
    ema_decay: float = DEFAULT_EMA_DECAY,
    val_sample_steps: int = DEFAULT_VAL_SAMPLE_STEPS,
    sample_only: Optional[str] = None,
):
    base = Path(base_dir)
    train_list = train_list or (base / "train_list.txt")
    ckpt_dir = base / "checkpoints_cond_blur3"
    samples_dir = base / "samples_cond_blur3"
    progress_dir = base / "progress_cond_blur3"
    ckpt_dir.mkdir(parents=True, exist_ok=True)
    samples_dir.mkdir(parents=True, exist_ok=True)
    progress_dir.mkdir(parents=True, exist_ok=True)

    device = get_device()
    print("Device:", device)

    model = UNetCond(in_ch=2, base=base_channels).to(device)
    diffusion = Diffusion(timesteps=timesteps, device=device).to(device)

    if sample_only:
        ck = safe_torch_load(Path(sample_only), map_location=device)
        sd = ck.get("model", ck) if isinstance(ck, dict) else ck
        sd = remap_checkpoint_to_model(sd, model)
        model.load_state_dict(sd, strict=False)
        model_for_sampling = model
        if isinstance(ck, dict) and "ema" in ck:
            try:
                ema_sd = remap_checkpoint_to_model(ck["ema"], model)
                tmp = UNetCond(in_ch=2, base=base_channels).to(device)
                tmp.load_state_dict(ema_sd, strict=False)
                model_for_sampling = tmp
                print("[SAMPLE_ONLY] Using EMA from checkpoint for sampling.")
            except Exception as e:
                print("[SAMPLE_ONLY] EMA load failed, using raw model:", e)
        conds = []
        with open(train_list, "r") as f:
            for i, line in enumerate(f):
                if i >= 4: break
                p = Path(line.strip())
                im = Image.open(p).convert("L").resize((image_size, image_size))
                b = im.filter(ImageFilter.GaussianBlur(radius=3.0))
                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
                conds.append(torch.from_numpy(arr).unsqueeze(0).unsqueeze(0).float())
        cond_batch = torch.cat(conds, dim=0).to(device)
        with torch.no_grad():
            samples = diffusion.sample_conditional(model_for_sampling, cond_batch, device=device, num_steps=val_sample_steps)
        out = samples_dir / f"samples_cond_sampleonly_{Path(sample_only).stem}.png"
        save_grid(samples, out, nrow=2)
        return

    ds = ConditionalMRI(str(train_list), image_size=image_size, blur_radius=3.0)
    dl = DataLoader(ds, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)

    opt = torch.optim.AdamW(model.parameters(), lr=lr)
    ema = EMA(model, decay=ema_decay)

    latest = ckpt_dir / "cond_latest.pt"
    start_step = 0
    if latest.exists():
        print("Resuming from", latest)
        data = safe_torch_load(latest, map_location=device)
        raw_model_sd = data.get("model", data) if isinstance(data, dict) else data
        raw_model_sd = remap_checkpoint_to_model(raw_model_sd, model)
        try:
            model.load_state_dict(raw_model_sd)
            print("[LOAD] model loaded (strict=True).")
        except Exception as e:
            print("[LOAD] strict load failed:", e)
            model.load_state_dict(raw_model_sd, strict=False)
            print("[LOAD] model loaded (strict=False). Some keys may be missing/unexpected.")

        if isinstance(data, dict) and "optimizer" in data:
            print("[LOAD] Skipping optimizer state load (always resume with fresh optimizer).")

        if isinstance(data, dict) and "ema" in data:
            try:
                ema_sd = remap_checkpoint_to_model(data["ema"], model)
                model_keys = set(model.state_dict().keys())
                ema_keys = set(ema_sd.keys())
                if ema_keys == model_keys:
                    ema.load_state_dict(ema_sd)
                    print("[LOAD] EMA loaded from checkpoint.")
                else:
                    print("[WARN] EMA keys do not match model keys (mismatch). Rebuilding EMA from current model.")
                    ema = EMA(model, decay=ema_decay)
                    for g in opt.param_groups:
                        g["lr"] = min(g.get("lr", lr), 5e-05)
                    print("[SAFE] Optimizer LR reduced to", opt.param_groups[0]["lr"])
            except Exception as e:
                print("[WARN] Failed to load EMA from checkpoint:", e)
                ema = EMA(model, decay=ema_decay)
        else:
            print("[WARN] No EMA present in checkpoint. Rebuilding EMA from current model and using SAFE low LR.")
            ema = EMA(model, decay=ema_decay)
            for g in opt.param_groups:
                g["lr"] = min(g.get("lr", lr), 5e-05)
            print("[SAFE] Optimizer LR reduced to", opt.param_groups[0]["lr"])

        start_step = int(data.get("step", 0)) if isinstance(data, dict) else 0
        print("Resumed at step:", start_step)

    stop = {"flag": False}
    def handler(sig, frame):
        print("\nSignal received: will save checkpoint and exit after current batch.")
        stop["flag"] = True
    signal.signal(signal.SIGINT, handler)
    signal.signal(signal.SIGTERM, handler)

    model.train()
    pbar = tqdm(total=total_steps, initial=start_step, desc="Train", ncols=120)
    step = start_step
    ema_loss = None

    try:
        while step < total_steps:
            for x0, cond in dl:
                if stop["flag"]:
                    break
                x0 = x0.to(device); cond = cond.to(device)
                bsz = x0.shape[0]
                t = torch.randint(0, timesteps, (bsz,), device=device).long()
                loss = diffusion.p_losses(model, x0, cond, t)

                opt.zero_grad()
                loss.backward()
                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
                opt.step()
                ema.update(model)

                step += 1
                val = float(loss.item())
                ema_loss = val if ema_loss is None else 0.9 * ema_loss + 0.1 * val

                if step % 50 == 0:
                    print(f"[{step}/{total_steps}] loss={val:.6f} ema={ema_loss:.6f}")

                pbar.set_postfix({"loss": f"{val:.3e}", "ema": f"{ema_loss:.3e}"})
                pbar.update(1)

                if step % sample_every == 0 or step == 1:
                    with torch.no_grad():
                        try:
                            sample_model = UNetCond(in_ch=2, base=base_channels).to(device)
                            try:
                                ema_sd = ema.to_state_dict()
                                ema_sd = remap_checkpoint_to_model(ema_sd, sample_model)
                                sample_model.load_state_dict(ema_sd, strict=False)
                                print("[SAMPLE] Using EMA shadow for sampling (remapped if needed).")
                            except Exception:
                                try:
                                    sample_model.load_state_dict(ema.shadow, strict=False)
                                    print("[SAMPLE] Loaded EMA shadow (fallback strict=False).")
                                except Exception as e:
                                    print("[SAMPLE] EMA load fallback failed, using raw model for sampling:", e)
                                    sample_model = model
                        except Exception as e:
                            print("[SAMPLE] Failed to build EMA sample model:", e)
                            sample_model = model

                        cond_batch = cond[:4].to(device)
                        samples = diffusion.sample_conditional(sample_model, cond_batch, device=device, num_steps=val_sample_steps)
                        s_path = samples_dir / f"samples_cond_{step}.png"
                        p_path = progress_dir / f"progress_cond_{step}.png"
                        save_grid(samples, s_path, nrow=2)
                        save_grid(samples, p_path, nrow=2)
                        print(f"[SAMPLE] Saved sample: {s_path}")
                        print(f"[SAMPLE] Saved progress: {p_path}")

                if step % save_every == 0 or stop["flag"] or step >= total_steps:
                    ck = {
                        "model": model.state_dict(),
                        "optimizer": opt.state_dict(),
                        "ema": ema.to_state_dict(),
                        "step": step,
                    }
                    p1 = ckpt_dir / f"cond_step_{step}.pt"
                    p2 = ckpt_dir / "cond_latest.pt"
                    atomic_save(ck, p1)
                    atomic_save(ck, p2)
                    print(f"[CKPT] Saved checkpoint: {p1}")
                    print(f"[CKPT] Updated latest checkpoint: {p2}")

                if step >= total_steps:
                    break
            if stop["flag"]:
                break
    finally:
        pbar.close()
        ck = {
            "model": model.state_dict(),
            "optimizer": opt.state_dict(),
            "ema": ema.to_state_dict(),
            "step": step,
        }
        atomic_save(ck, ckpt_dir / f"cond_step_{step}.pt")
        atomic_save(ck, ckpt_dir / "cond_latest.pt")
        print("[FINAL] Final checkpoint saved.")
        print("Exiting.")

# --------------------------
# CLI
# --------------------------
def parse_args():
    p = argparse.ArgumentParser()
    p.add_argument("--base_dir", default=str(DEFAULT_BASE_DIR))
    p.add_argument("--train_list", default=None, help="path to train list (one image per line)")
    p.add_argument("--image_size", type=int, default=DEFAULT_IMAGE_SIZE)
    p.add_argument("--batch_size", type=int, default=DEFAULT_BATCH_SIZE)
    p.add_argument("--num_workers", type=int, default=DEFAULT_NUM_WORKERS)
    p.add_argument("--timesteps", type=int, default=DEFAULT_TIMESTEPS)
    p.add_argument("--total_steps", type=int, default=DEFAULT_TOTAL_STEPS)
    p.add_argument("--lr", type=float, default=DEFAULT_LR)
    p.add_argument("--base_channels", type=int, default=64)
    p.add_argument("--save_every", type=int, default=DEFAULT_SAVE_EVERY)
    p.add_argument("--sample_every", type=int, default=DEFAULT_SAMPLE_EVERY)
    p.add_argument("--ema_decay", type=float, default=DEFAULT_EMA_DECAY)
    p.add_argument("--val_sample_steps", type=int, default=DEFAULT_VAL_SAMPLE_STEPS)
    p.add_argument("--sample_only", default=None, help="path to ckpt to sample and exit")
    return p.parse_args()

if __name__ == "__main__":
    args = parse_args()
    train(
        base_dir=args.base_dir,
        train_list=args.train_list,
        image_size=args.image_size,
        batch_size=args.batch_size,
        num_workers=args.num_workers,
        timesteps=args.timesteps,
        total_steps=args.total_steps,
        lr=args.lr,
        base_channels=args.base_channels,
        save_every=args.save_every,
        sample_every=args.sample_every,
        ema_decay=args.ema_decay,
        val_sample_steps=args.val_sample_steps,
        sample_only=args.sample_only,
    )