add training scripts

training_scripts/train_blur_brats_1.py

@@ -0,0 +1,562 @@
+#!/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 = 1.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_blur1"
+    samples_dir = base / "samples_cond_blur1"
+    progress_dir = base / "progress_cond_blur1"
+    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=1.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=1.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,
+    )

training_scripts/train_blur_brats_2.py

@@ -0,0 +1,562 @@
+#!/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 = 2.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_blur2"
+    samples_dir = base / "samples_cond_blur2"
+    progress_dir = base / "progress_cond_blur2"
+    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=2.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=2.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,
+    )

training_scripts/train_blur_brats_3.py

@@ -0,0 +1,562 @@
+#!/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,
+    )

training_scripts/train_blur_brats_half.py

@@ -0,0 +1,562 @@
+#!/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 = 0.5):
+        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_blur_0.5"
+    samples_dir = base / "samples_cond_blur_0.5"
+    progress_dir = base / "progress_cond_blur_0.5"
+    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=0.5))
+                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=0.5)
+    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,
+    )

training_scripts/train_buildings_blur0.5.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 256
+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 = 0.5):
+        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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        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, 3, 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("RGB", (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].transpose(1, 2, 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_buildings.txt")
+    ckpt_dir = base / "checkpoints_cond_blur_0.5_buildings"
+    samples_dir = base / "samples_cond_blur_0.5_buildings"
+    progress_dir = base / "progress_cond_blur_0.5_buildings"
+    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=6, 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=6, 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("RGB")
+                b = im.filter(ImageFilter.GaussianBlur(radius=0.5))
+                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
+                conds.append(
+                    torch.from_numpy(arr).permute(2, 0, 1).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=0.5)
+    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=6, 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,
+    )

training_scripts/train_buildings_blur1.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 256
+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 = 1.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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        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, 3, 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("RGB", (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].transpose(1, 2, 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_buildings.txt")
+    ckpt_dir = base / "checkpoints_cond_blur1_buildings"
+    samples_dir = base / "samples_cond_blur1_buildings"
+    progress_dir = base / "progress_cond_blur1_buildings"
+    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=6, 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=6, 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("RGB")
+                b = im.filter(ImageFilter.GaussianBlur(radius=1.0))
+                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
+                conds.append(
+                    torch.from_numpy(arr).permute(2, 0, 1).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=1.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=6, 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,
+    )

training_scripts/train_buildings_blur2.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 256
+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 = 2.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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        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, 3, 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("RGB", (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].transpose(1, 2, 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_buildings.txt")
+    ckpt_dir = base / "checkpoints_cond_blur2_buildings"
+    samples_dir = base / "samples_cond_blur2_buildings"
+    progress_dir = base / "progress_cond_blur2_buildings"
+    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=6, 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=6, 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("RGB")
+                b = im.filter(ImageFilter.GaussianBlur(radius=2.0))
+                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
+                conds.append(
+                    torch.from_numpy(arr).permute(2, 0, 1).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=2.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=6, 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,
+    )

training_scripts/train_buildings_blur3.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 256
+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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        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, 3, 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("RGB", (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].transpose(1, 2, 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_buildings.txt")
+    ckpt_dir = base / "checkpoints_cond_blur3_buildings"
+    samples_dir = base / "samples_cond_blur3_buildings"
+    progress_dir = base / "progress_cond_blur3_buildings"
+    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=6, 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=6, 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("RGB")
+                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).permute(2, 0, 1).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=6, 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,
+    )

training_scripts/train_celebA_blur1.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 176
+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 = 1.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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        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, 3, 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("RGB", (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].transpose(1, 2, 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_celebA.txt")
+    ckpt_dir = base / "checkpoints_cond_blur1_rgb"
+    samples_dir = base / "samples_cond_blur1_rgb"
+    progress_dir = base / "progress_cond_blur1_rgb"
+    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=6, 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=6, 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("RGB")
+                b = im.filter(ImageFilter.GaussianBlur(radius=1.0))
+                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
+                conds.append(
+                    torch.from_numpy(arr).permute(2, 0, 1).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=1.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=6, 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,
+    )

training_scripts/train_celebA_blur2.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 176
+DEFAULT_BATCH_SIZE = 8
+DEFAULT_NUM_WORKERS = 2
+DEFAULT_TIMESTEPS = 1000
+DEFAULT_TOTAL_STEPS = 600000
+DEFAULT_LR = 5e-5
+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 = 2.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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        cond_feat = self.cond_proj(cond)
+
+        d1 = self.down1(torch.cat([noisy, cond], dim=1), t_emb)
+        try:
+            d1 = d1 + 0.5 * 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, 3, 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("RGB", (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].transpose(1, 2, 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_celebA.txt")
+    ckpt_dir = base / "checkpoints_cond_blur2_rgb"
+    samples_dir = base / "samples_cond_blur2_rgb"
+    progress_dir = base / "progress_cond_blur2_rgb"
+    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=6, 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=6, 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("RGB")
+                b = im.filter(ImageFilter.GaussianBlur(radius=2.0))
+                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
+                conds.append(
+                    torch.from_numpy(arr).permute(2, 0, 1).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=2.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=6, 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,
+    )

training_scripts/train_celebA_blur3.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 176
+DEFAULT_BATCH_SIZE = 8
+DEFAULT_NUM_WORKERS = 2
+DEFAULT_TIMESTEPS = 1000
+DEFAULT_TOTAL_STEPS = 600000
+DEFAULT_LR = 5e-5
+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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        cond_feat = self.cond_proj(cond)
+
+        d1 = self.down1(torch.cat([noisy, cond], dim=1), t_emb)
+        try:
+            d1 = d1 + 0.5 * 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, 3, 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("RGB", (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].transpose(1, 2, 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_celebA.txt")
+    ckpt_dir = base / "checkpoints_cond_blur3_rgb"
+    samples_dir = base / "samples_cond_blur3_rgb"
+    progress_dir = base / "progress_cond_blur3_rgb"
+    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=6, 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=6, 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("RGB")
+                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).permute(2, 0, 1).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=6, 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,
+    )

training_scripts/train_celebA_blur_half.py

@@ -0,0 +1,568 @@
+#!/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")
+DEFAULT_IMAGE_SIZE = 176
+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 = 0.5):
+        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("RGB")
+        assert img.size == (self.image_size, self.image_size), f"Bad image size: {img.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).permute(2, 0, 1).float()
+        b_t = torch.from_numpy(b).permute(2, 0, 1).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=6, 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(3, 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, 3, 1)
+
+    def forward(self, noisy_and_cond, t):
+        device = noisy_and_cond.device
+        t_emb = self.time_mlp(t)
+
+        noisy = noisy_and_cond[:, :3, ...]
+        cond = noisy_and_cond[:, 3:, ...]
+        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, 3, 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("RGB", (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].transpose(1, 2, 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_celebA.txt")
+    ckpt_dir = base / "checkpoints_cond_blur0.5_rgb"
+    samples_dir = base / "samples_cond_blur0.5_rgb"
+    progress_dir = base / "progress_cond_blur0.5_rgb"
+    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=6, 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=6, 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("RGB")
+                b = im.filter(ImageFilter.GaussianBlur(radius=0.5))
+                arr = (np.array(b, dtype=np.float32) / 255.0) * 2.0 - 1.0
+                conds.append(
+                    torch.from_numpy(arr).permute(2, 0, 1).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=0.5)
+    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=6, 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,
+    )