source_code/sam3/medsam3_brats/4_predict_sam3.py

#!/usr/bin/env python3
"""
SAM3 + LoRA 推理脚本 - 与 SegMamba 的 4_predict.py 保持一致的评估流程

读取 SegMamba 格式的预处理数据 (.npz)，使用 SAM3 + LoRA + decoder 进行推理，
输出与 SegMamba 相同格式的预测结果。
"""

import argparse
import glob
import os
import sys
from pathlib import Path

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import SimpleITK as sitk
from tqdm import tqdm
import random

sys.path.insert(0, "/root/githubs/sam3")
sys.path.insert(0, "/root/githubs/SegMamba")

# Set determinism
random.seed(123)
np.random.seed(123)
torch.manual_seed(123)


def dice(pred, gt):
    """计算 Dice 系数"""
    pred = pred.astype(bool)
    gt = gt.astype(bool)
    intersection = np.sum(pred & gt)
    union = np.sum(pred) + np.sum(gt)
    if union == 0:
        return 1.0 if np.sum(pred) == 0 else 0.0
    return 2.0 * intersection / union


class MedSAM3DetectorSeg(nn.Module):
    """
    与训练时相同的模型结构：SAM3 detector backbone -> lightweight decoder -> mask logits
    4 类分割: 0=背景, 1=NCR, 2=ED, 3=ET
    """

    def __init__(self, sam3_detector: nn.Module, image_size: int = 1008, num_classes: int = 4):
        super().__init__()
        self.detector = sam3_detector
        self.image_size = int(image_size)
        self.num_classes = num_classes
        self.register_buffer("mean", torch.tensor([0.5, 0.5, 0.5]).view(1, 3, 1, 1))
        self.register_buffer("std", torch.tensor([0.5, 0.5, 0.5]).view(1, 3, 1, 1))

        # lightweight decoder; expects a 256-channel feature map from SAM3 backbone
        # 输出 num_classes 通道 (4 类分割)
        self.decoder = nn.Sequential(
            nn.Conv2d(256, 128, 3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Upsample(scale_factor=2, mode="bilinear", align_corners=False),
            nn.Conv2d(128, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Upsample(scale_factor=2, mode="bilinear", align_corners=False),
            nn.Conv2d(64, 32, 3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.Upsample(scale_factor=2, mode="bilinear", align_corners=False),
            nn.Conv2d(32, num_classes, 1),  # 4 类输出
        )

    def _preprocess(self, images: torch.Tensor) -> torch.Tensor:
        _, _, h, w = images.shape
        if h != self.image_size or w != self.image_size:
            images = F.interpolate(
                images, size=(self.image_size, self.image_size), mode="bilinear", align_corners=False
            )
        images = (images - self.mean.to(images.device)) / self.std.to(images.device)
        return images

    def _pick_feat(self, backbone_out) -> torch.Tensor:
        feat = None
        if isinstance(backbone_out, dict):
            if "sam3_features" in backbone_out:
                feat = backbone_out["sam3_features"]
            elif "features" in backbone_out:
                feat = backbone_out["features"]
            else:
                for _, v in backbone_out.items():
                    if isinstance(v, torch.Tensor) and v.ndim == 4:
                        feat = v
                        break
        elif isinstance(backbone_out, torch.Tensor):
            feat = backbone_out
        if feat is None or not isinstance(feat, torch.Tensor) or feat.ndim != 4:
            raise RuntimeError("Could not find a 4D feature map in SAM3 backbone output")
        return feat

    def forward(self, images: torch.Tensor) -> torch.Tensor:
        orig_h, orig_w = images.shape[-2:]
        x = self._preprocess(images)
        backbone_out = self.detector.backbone.forward_image(x)
        feat = self._pick_feat(backbone_out)
        logits = self.decoder(feat)  # (B, num_classes, ?, ?)
        if logits.shape[-2:] != (orig_h, orig_w):
            logits = F.interpolate(logits, size=(orig_h, orig_w), mode="bilinear", align_corners=False)
        return logits  # (B, num_classes, H, W)


def load_model(checkpoint_path: str, lora_weights: str, decoder_weights: str = None, device: str = "cuda"):
    """加载 SAM3 + LoRA 模型"""
    from sam3.model_builder import build_sam3_video_model
    from lora import apply_lora_to_model, load_lora_weights

    print(f"Loading SAM3 from: {checkpoint_path}")
    sam3 = build_sam3_video_model(
        checkpoint_path=checkpoint_path,
        load_from_HF=False,
        device=device,
        apply_temporal_disambiguation=True,
    )

    # 创建分割模型 (4 类: 背景 + 3 类肿瘤)
    model = MedSAM3DetectorSeg(sam3.detector, image_size=1008, num_classes=4)

    # 注入 LoRA
    target_modules = ["q_proj", "k_proj", "v_proj", "out_proj", "qkv", "proj"]
    print(f"Applying LoRA to detector...")
    apply_lora_to_model(
        model.detector,
        rank=8,
        alpha=16.0,
        dropout=0.0,
        target_modules=target_modules,
        exclude_modules=[],
    )

    # 加载 LoRA 权重
    print(f"Loading LoRA weights from: {lora_weights}")
    load_lora_weights(model.detector, lora_weights)

    # 加载 decoder 权重
    if decoder_weights is not None:
        decoder_path = Path(decoder_weights)
    else:
        decoder_path = Path(lora_weights).parent / "best_decoder_weights.pt"
    
    if decoder_path.exists():
        print(f"Loading decoder weights from: {decoder_path}")
        decoder_state = torch.load(decoder_path, map_location="cpu")
        model.decoder.load_state_dict(decoder_state)
    else:
        print(f"WARNING: Decoder weights not found at {decoder_path}")
        print("The model will use randomly initialized decoder - predictions will be wrong!")
        print("Please retrain with the updated training script that saves decoder weights.")

    model = model.to(device)
    model.eval()
    return model


def convert_labels(labels):
    """
    转换标签为 3 通道 (TC, WT, ET)
    - TC (Tumor Core): label==1 或 label==3
    - WT (Whole Tumor): label==1 或 label==2 或 label==3
    - ET (Enhancing Tumor): label==3
    """
    result = [
        (labels == 1) | (labels == 3),  # TC
        (labels == 1) | (labels == 2) | (labels == 3),  # WT
        labels == 3,  # ET
    ]
    return np.stack(result, axis=0).astype(np.float32)


def predict_volume(model, volume_4d: np.ndarray, modality: int = 0, 
                   target_size: int = 512, device: str = "cuda") -> np.ndarray:
    """
    对 4D volume 进行 4 类分割预测
    
    Args:
        model: 分割模型 (输出 4 类)
        volume_4d: (4, D, H, W) 的 4 模态 3D volume
        modality: 使用的模态索引（0=T1, 1=T1ce, 2=T2, 3=FLAIR）
        target_size: 目标尺寸
        device: 计算设备
    
    Returns:
        pred_3d: (D, H, W) 的类别预测 (0=背景, 1=NCR, 2=ED, 3=ET)
    """
    # 提取指定模态
    volume = volume_4d[modality]  # (D, H, W)
    D, H, W = volume.shape
    
    pred_3d = np.zeros((D, H, W), dtype=np.uint8)
    
    with torch.no_grad():
        for z in range(D):
            slice_2d = volume[z]  # (H, W)
            
            # 归一化到 [0, 1]
            v_min, v_max = slice_2d.min(), slice_2d.max()
            if v_max > v_min:
                slice_2d = (slice_2d - v_min) / (v_max - v_min)
            else:
                slice_2d = np.zeros_like(slice_2d)
            
            # 转为 3 通道 RGB
            slice_rgb = np.stack([slice_2d] * 3, axis=0)  # (3, H, W)
            
            # Resize to target size
            slice_tensor = torch.from_numpy(slice_rgb).float().unsqueeze(0)  # (1, 3, H, W)
            if H != target_size or W != target_size:
                slice_tensor = F.interpolate(slice_tensor, size=(target_size, target_size), 
                                            mode="bilinear", align_corners=False)
            
            slice_tensor = slice_tensor.to(device)
            
            # 推理 - 4 类输出
            logits = model(slice_tensor)  # (1, 4, H, W)
            pred_class = logits.argmax(dim=1)  # (1, H, W)
            
            # Resize back to original size
            if H != target_size or W != target_size:
                pred_class = F.interpolate(pred_class.unsqueeze(1).float(), size=(H, W), 
                                          mode="nearest").squeeze(1).long()
            
            pred_3d[z] = pred_class[0].cpu().numpy()
    
    return pred_3d


def labels_to_regions(pred_3d: np.ndarray) -> dict:
    """
    将 4 类预测转换为 TC/WT/ET 区域
    
    BraTS 标签:
        0: 背景
        1: NCR (Necrotic tumor core)
        2: ED (Peritumoral Edema)
        3: ET (Enhancing tumor)
    
    区域定义:
        TC (Tumor Core) = NCR + ET = label 1 + label 3
        WT (Whole Tumor) = NCR + ED + ET = label 1 + label 2 + label 3
        ET (Enhancing Tumor) = label 3
    """
    tc = ((pred_3d == 1) | (pred_3d == 3)).astype(np.uint8)
    wt = ((pred_3d == 1) | (pred_3d == 2) | (pred_3d == 3)).astype(np.uint8)
    et = (pred_3d == 3).astype(np.uint8)
    return {"TC": tc, "WT": wt, "ET": et}


def main():
    parser = argparse.ArgumentParser(description="SAM3+LoRA inference for BraTS2023 (SegMamba-compatible)")
    
    # 数据参数
    parser.add_argument("--data_dir", type=str, default="/data/yty/brats23_processed",
                        help="Preprocessed data directory (contains *.npz)")
    parser.add_argument("--split", type=str, default="test", choices=["train", "val", "test", "all"])
    parser.add_argument("--train_rate", type=float, default=0.7)
    parser.add_argument("--val_rate", type=float, default=0.1)
    parser.add_argument("--test_rate", type=float, default=0.2)
    parser.add_argument("--seed", type=int, default=42)
    
    # 模型参数
    parser.add_argument("--checkpoint", type=str, default="/data/yty/sam3/sam3.pt",
                        help="SAM3 checkpoint path")
    parser.add_argument("--lora_weights", type=str, 
                        default="/data/yty/brats23_sam3_video_lora_bestonly_122/checkpoints/best_lora_weights.pt",
                        help="LoRA weights path")
    parser.add_argument("--decoder_weights", type=str, default=None,
                        help="Decoder weights path (default: auto-detect from lora_weights dir)")
    parser.add_argument("--modality", type=int, default=0,
                        help="Which modality to use (0=T1, 1=T1ce, 2=T2, 3=FLAIR)")
    parser.add_argument("--target_size", type=int, default=512,
                        help="Target image size for inference")
    
    # 输出参数
    parser.add_argument("--save_dir", type=str, default="/data/yty/brats23_sam3_predictions",
                        help="Directory to save predictions")
    parser.add_argument("--device", type=str, default="cuda:0")
    parser.add_argument("--raw_spacing", type=str, default="1,1,1")
    parser.add_argument("--print_dice", action="store_true", help="Print dice for each case")
    
    args = parser.parse_args()
    
    raw_spacing = [float(x) for x in args.raw_spacing.split(",")]
    
    # 加载模型
    model = load_model(args.checkpoint, args.lora_weights, args.decoder_weights, args.device)
    
    # 获取数据集
    all_paths = sorted(glob.glob(os.path.join(args.data_dir, "*.npz")))
    all_names = [os.path.splitext(os.path.basename(p))[0] for p in all_paths]
    
    if args.split == "all":
        cases = list(zip(all_names, all_paths))
    else:
        # 按比例划分
        n = len(all_names)
        indices = list(range(n))
        rng = np.random.RandomState(args.seed)
        rng.shuffle(indices)
        
        n_train = int(n * args.train_rate)
        n_val = int(n * args.val_rate)
        
        train_idx = indices[:n_train]
        val_idx = indices[n_train:n_train + n_val]
        test_idx = indices[n_train + n_val:]
        
        split_map = {"train": train_idx, "val": val_idx, "test": test_idx}
        selected_idx = split_map[args.split]
        
        cases = [(all_names[i], all_paths[i]) for i in selected_idx]
    
    print(f"Found {len(cases)} cases for split '{args.split}'")
    
    os.makedirs(args.save_dir, exist_ok=True)
    
    all_dices = []
    
    for case_name, npz_path in tqdm(cases, desc="Predicting"):
        # 加载数据
        data = np.load(npz_path)
        image_4d = data["data"]  # (4, D, H, W)
        seg = data.get("seg", None)  # (1, D, H, W) or None
        
        # 预测 - 4 类分割
        pred_classes = predict_volume(model, image_4d, modality=args.modality, 
                                      target_size=args.target_size, device=args.device)
        
        # 转换为 TC/WT/ET 区域
        pred_regions = labels_to_regions(pred_classes)
        D, H, W = pred_classes.shape
        pred_3c = np.stack([pred_regions["TC"], pred_regions["WT"], pred_regions["ET"]], axis=0)
        
        # 计算 dice（如果有 GT）
        if seg is not None and args.print_dice:
            gt = seg[0]  # (D, H, W)
            gt_3c = convert_labels(gt)
            
            dices = []
            for i, name in enumerate(["TC", "WT", "ET"]):
                d = dice(pred_3c[i], gt_3c[i])
                dices.append(d)
            
            # 也计算整体 tumor 的 dice
            gt_binary = (gt > 0).astype(np.float32)
            pred_binary = (pred_classes > 0).astype(np.float32)
            overall_dice = dice(pred_binary, gt_binary)
            
            print(f"{case_name}: TC={dices[0]:.4f}, WT={dices[1]:.4f}, ET={dices[2]:.4f}, Overall={overall_dice:.4f}")
            all_dices.append({
                "case": case_name,
                "TC": dices[0],
                "WT": dices[1],
                "ET": dices[2],
                "Overall": overall_dice,
            })
        
        # 保存预测
        out_path = os.path.join(args.save_dir, f"{case_name}.nii.gz")
        pred_itk = sitk.GetImageFromArray(pred_3c, isVector=False)
        pred_itk.SetSpacing((raw_spacing[0], raw_spacing[1], raw_spacing[2], 1.0))
        sitk.WriteImage(pred_itk, out_path)
    
    # 汇总结果
    if all_dices:
        print("\n" + "=" * 60)
        print(f"Results Summary ({len(all_dices)} cases):")
        avg_tc = np.mean([d["TC"] for d in all_dices])
        avg_wt = np.mean([d["WT"] for d in all_dices])
        avg_et = np.mean([d["ET"] for d in all_dices])
        avg_overall = np.mean([d["Overall"] for d in all_dices])
        print(f"  Average TC Dice:      {avg_tc:.4f}")
        print(f"  Average WT Dice:      {avg_wt:.4f}")
        print(f"  Average ET Dice:      {avg_et:.4f}")
        print(f"  Average Overall Dice: {avg_overall:.4f}")
        print("=" * 60)
        
        # 保存结果
        np.save(os.path.join(args.save_dir, "metrics.npy"), all_dices, allow_pickle=True)


if __name__ == "__main__":
    main()