source_code/sam3/medsam3_brats/train_sam3_lora.py

#!/usr/bin/env python3
"""
SAM3 LoRA微调训练脚本 - BraTS脑肿瘤分割

使用SAM3的正确API，配合LoRA进行高效微调
"""

import os
import sys
import argparse
import json
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.cuda.amp import GradScaler
from torch.amp import autocast
from torch.utils.tensorboard import SummaryWriter
from pathlib import Path
from datetime import datetime
from tqdm import tqdm
from typing import Dict, Any, Optional, List

# 添加SAM3路径
sys.path.insert(0, '/root/githubs/sam3')

from brats_dataset import BraTSImageDataset, collate_fn_brats
from lora import (
    apply_lora_to_model,
    count_parameters,
    save_lora_weights,
    freeze_model_except_lora
)


def setup_device():
    """设置计算设备"""
    if torch.cuda.is_available():
        device = torch.device("cuda")
        print(f"Using GPU: {torch.cuda.get_device_name(0)}")
        # 启用TF32
        torch.backends.cuda.matmul.allow_tf32 = True
        torch.backends.cudnn.allow_tf32 = True
    else:
        device = torch.device("cpu")
        print("Using CPU")
    return device


def dice_loss(pred: torch.Tensor, target: torch.Tensor, smooth: float = 1.0) -> torch.Tensor:
    """Dice Loss"""
    pred = torch.sigmoid(pred)
    pred_flat = pred.view(-1)
    target_flat = target.view(-1).float()
    
    intersection = (pred_flat * target_flat).sum()
    union = pred_flat.sum() + target_flat.sum()
    
    dice = (2.0 * intersection + smooth) / (union + smooth)
    return 1.0 - dice


def focal_loss(pred: torch.Tensor, target: torch.Tensor, alpha: float = 0.25, gamma: float = 2.0) -> torch.Tensor:
    """Focal Loss"""
    bce = F.binary_cross_entropy_with_logits(pred, target.float(), reduction='none')
    pt = torch.exp(-bce)
    focal = alpha * (1 - pt) ** gamma * bce
    return focal.mean()


def combined_loss(pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
    """组合损失"""
    return 0.5 * dice_loss(pred, target) + 0.5 * focal_loss(pred, target)


def compute_dice(pred: torch.Tensor, target: torch.Tensor) -> float:
    """计算Dice系数"""
    pred = (torch.sigmoid(pred) > 0.5).float()
    pred_flat = pred.view(-1)
    target_flat = target.view(-1).float()
    
    intersection = (pred_flat * target_flat).sum()
    union = pred_flat.sum() + target_flat.sum()
    
    if union == 0:
        return 1.0
    
    dice = (2.0 * intersection) / union
    return dice.item()


class SAM3SegmentationWrapper(nn.Module):
    """
    SAM3分割包装器
    将SAM3模型包装成适合训练的形式
    """
    
    def __init__(self, sam3_model, image_size: int = 1008):
        super().__init__()
        self.sam3_model = sam3_model
        self.image_size = image_size  # SAM3需要1008x1008
        
        # SAM3的归一化参数
        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))
    
    def preprocess(self, images: torch.Tensor) -> torch.Tensor:
        """预处理图像 - Resize到1008x1008"""
        B, C, H, W = images.shape
        
        # SAM3必须使用1008x1008输入
        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)
        
        # 归一化 (输入范围0-1 -> 归一化到[-1, 1])
        images = (images - self.mean.to(images.device)) / self.std.to(images.device)
        
        return images
    
    def forward(self, images: torch.Tensor, bboxes: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            images: (B, C, H, W) 输入图像，范围0-1
            bboxes: (B, 4) 归一化的bbox坐标 [x1, y1, x2, y2]
        
        Returns:
            masks: (B, H, W) 预测的mask logits
        """
        B, C, orig_H, orig_W = images.shape
        
        # 预处理
        processed_images = self.preprocess(images)
        
        # 获取backbone特征
        backbone = self.sam3_model.backbone
        
        # 使用forward_image提取特征
        # 需要将图像包装成NestedTensor格式
        backbone_out = backbone.forward_image(processed_images)
        
        # 获取分割结果
        # 这里我们使用segmentation_head
        if hasattr(self.sam3_model, 'segmentation_head') and self.sam3_model.segmentation_head is not None:
            # 构建decoder输入
            # SAM3的segmentation_head需要特定的输入格式
            seg_head = self.sam3_model.segmentation_head
            
            # 从backbone_out提取特征
            if isinstance(backbone_out, dict):
                features = backbone_out.get('features', backbone_out.get('sam3_features'))
            else:
                features = backbone_out
            
            # 使用pixel decoder
            if hasattr(seg_head, 'pixel_decoder'):
                # 需要适配输入格式
                pass
        
        # 简化版：使用一个轻量级解码器
        # 从backbone提取的特征进行解码
        if not hasattr(self, '_decoder'):
            self._create_decoder(images.device)
        
        # 获取多尺度特征
        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:
                # 找到第一个tensor
                for k, v in backbone_out.items():
                    if isinstance(v, torch.Tensor) and v.ndim == 4:
                        feat = v
                        break
        else:
            feat = backbone_out
        
        # 解码
        if isinstance(feat, torch.Tensor):
            masks = self._decoder(feat)
        else:
            masks = torch.zeros(B, 1, self.image_size, self.image_size, device=images.device)
        
        # Resize回原始尺寸
        if masks.shape[-2:] != (orig_H, orig_W):
            masks = F.interpolate(masks, size=(orig_H, orig_W), mode='bilinear', align_corners=False)
        
        return masks.squeeze(1)  # (B, H, W)
    
    def _create_decoder(self, device):
        """创建轻量级解码器"""
        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, 1, 1),
        ).to(device)


class SAM3Trainer:
    """SAM3训练器"""
    
    def __init__(
        self,
        model: nn.Module,
        train_loader: DataLoader,
        val_loader: DataLoader,
        optimizer: torch.optim.Optimizer,
        scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
        device: torch.device = torch.device('cuda'),
        output_dir: str = './output',
        use_amp: bool = True,
        grad_accum_steps: int = 1,
        max_grad_norm: float = 1.0,
    ):
        self.model = model
        self.train_loader = train_loader
        self.val_loader = val_loader
        self.optimizer = optimizer
        self.scheduler = scheduler
        self.device = device
        self.output_dir = Path(output_dir)
        self.use_amp = use_amp
        self.grad_accum_steps = grad_accum_steps
        self.max_grad_norm = max_grad_norm
        
        self.output_dir.mkdir(parents=True, exist_ok=True)
        (self.output_dir / 'checkpoints').mkdir(exist_ok=True)
        
        self.writer = SummaryWriter(str(self.output_dir / 'tensorboard'))
        self.scaler = GradScaler() if use_amp else None
        
        self.global_step = 0
        self.epoch = 0
        self.best_dice = 0.0
    
    def train_epoch(self) -> Dict[str, float]:
        """训练一个epoch"""
        self.model.train()
        
        total_loss = 0.0
        total_dice = 0.0
        num_batches = 0
        
        pbar = tqdm(self.train_loader, desc=f'Epoch {self.epoch}')
        
        for batch_idx, batch in enumerate(pbar):
            images = batch['images'].to(self.device)
            masks = batch['masks'].to(self.device)
            bboxes = batch['bboxes'].to(self.device)
            
            with autocast('cuda', enabled=self.use_amp):
                outputs = self.model(images, bboxes)
                loss = combined_loss(outputs, masks)
                loss = loss / self.grad_accum_steps
            
            if self.use_amp:
                self.scaler.scale(loss).backward()
            else:
                loss.backward()
            
            if (batch_idx + 1) % self.grad_accum_steps == 0:
                if self.use_amp:
                    self.scaler.unscale_(self.optimizer)
                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.max_grad_norm)
                    self.scaler.step(self.optimizer)
                    self.scaler.update()
                else:
                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.max_grad_norm)
                    self.optimizer.step()
                
                self.optimizer.zero_grad()
                self.global_step += 1
            
            with torch.no_grad():
                dice = compute_dice(outputs, masks)
            
            total_loss += loss.item() * self.grad_accum_steps
            total_dice += dice
            num_batches += 1
            
            pbar.set_postfix({'loss': f'{loss.item() * self.grad_accum_steps:.4f}', 'dice': f'{dice:.4f}'})
            
            if self.global_step % 10 == 0:
                self.writer.add_scalar('train/loss', loss.item() * self.grad_accum_steps, self.global_step)
                self.writer.add_scalar('train/dice', dice, self.global_step)
                self.writer.add_scalar('train/lr', self.optimizer.param_groups[0]['lr'], self.global_step)
        
        return {'loss': total_loss / num_batches, 'dice': total_dice / num_batches}
    
    @torch.no_grad()
    def validate(self) -> Dict[str, float]:
        """验证"""
        self.model.eval()
        
        total_loss = 0.0
        total_dice = 0.0
        num_batches = 0
        
        for batch in tqdm(self.val_loader, desc='Validating'):
            images = batch['images'].to(self.device)
            masks = batch['masks'].to(self.device)
            bboxes = batch['bboxes'].to(self.device)
            
            with autocast('cuda', enabled=self.use_amp):
                outputs = self.model(images, bboxes)
                loss = combined_loss(outputs, masks)
            
            dice = compute_dice(outputs, masks)
            
            total_loss += loss.item()
            total_dice += dice
            num_batches += 1
        
        avg_loss = total_loss / num_batches
        avg_dice = total_dice / num_batches
        
        self.writer.add_scalar('val/loss', avg_loss, self.global_step)
        self.writer.add_scalar('val/dice', avg_dice, self.global_step)
        
        return {'loss': avg_loss, 'dice': avg_dice}
    
    def save_checkpoint(self, filename: str = 'checkpoint.pt', is_best: bool = False):
        """保存检查点"""
        checkpoint = {
            'epoch': self.epoch,
            'global_step': self.global_step,
            'model_state_dict': self.model.state_dict(),
            'optimizer_state_dict': self.optimizer.state_dict(),
            'best_dice': self.best_dice,
        }
        
        if self.scheduler is not None:
            checkpoint['scheduler_state_dict'] = self.scheduler.state_dict()
        
        torch.save(checkpoint, self.output_dir / 'checkpoints' / filename)
        
        # 保存LoRA权重
        save_lora_weights(self.model, str(self.output_dir / 'checkpoints' / 'lora_weights.pt'))
        
        if is_best:
            torch.save(checkpoint, self.output_dir / 'checkpoints' / 'best_model.pt')
            save_lora_weights(self.model, str(self.output_dir / 'checkpoints' / 'best_lora_weights.pt'))
    
    def train(self, num_epochs: int, val_freq: int = 1):
        """完整训练循环"""
        print(f"\n{'='*60}")
        print(f"Starting training for {num_epochs} epochs")
        print(f"Output directory: {self.output_dir}")
        print(f"{'='*60}\n")
        
        for epoch in range(num_epochs):
            self.epoch = epoch
            
            train_metrics = self.train_epoch()
            print(f"Epoch {epoch}: train_loss={train_metrics['loss']:.4f}, train_dice={train_metrics['dice']:.4f}")
            
            if self.scheduler is not None:
                self.scheduler.step()
            
            if (epoch + 1) % val_freq == 0:
                val_metrics = self.validate()
                print(f"Epoch {epoch}: val_loss={val_metrics['loss']:.4f}, val_dice={val_metrics['dice']:.4f}")
                
                is_best = val_metrics['dice'] > self.best_dice
                if is_best:
                    self.best_dice = val_metrics['dice']
                    print(f"  New best dice: {self.best_dice:.4f}")
                
                self.save_checkpoint(f'checkpoint_epoch_{epoch}.pt', is_best=is_best)
            else:
                self.save_checkpoint(f'checkpoint_epoch_{epoch}.pt')
        
        self.save_checkpoint('final_checkpoint.pt')
        
        print(f"\n{'='*60}")
        print(f"Training completed! Best validation Dice: {self.best_dice:.4f}")
        print(f"{'='*60}\n")
        
        self.writer.close()


def build_sam3_for_training(checkpoint_path: str, device: str = 'cuda'):
    """构建用于训练的SAM3模型"""
    from sam3.model_builder import build_sam3_image_model
    
    print("Loading SAM3 model...")
    sam3_model = build_sam3_image_model(
        checkpoint_path=checkpoint_path,
        load_from_HF=False,
        device=device,
        eval_mode=False,  # 训练模式
        enable_segmentation=True,
    )
    
    # 包装模型
    model = SAM3SegmentationWrapper(sam3_model)
    model = model.to(device)
    
    return model


def main():
    parser = argparse.ArgumentParser(description='SAM3 LoRA Fine-tuning for BraTS')
    
    # 数据参数
    parser.add_argument('--data_root', type=str, 
                        default='/data/yty/brats2023/ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData')
    parser.add_argument('--modality', type=int, default=0)
    parser.add_argument('--target_size', type=int, nargs=2, default=[512, 512])
    
    # 模型参数
    parser.add_argument('--checkpoint', type=str, default='/data/yty/sam3/sam3.pt')
    parser.add_argument('--lora_rank', type=int, default=8)
    parser.add_argument('--lora_alpha', type=float, default=16.0)
    parser.add_argument('--lora_dropout', type=float, default=0.1)
    
    # 训练参数
    parser.add_argument('--epochs', type=int, default=50)
    parser.add_argument('--batch_size', type=int, default=4)
    parser.add_argument('--lr', type=float, default=1e-4)
    parser.add_argument('--weight_decay', type=float, default=0.01)
    parser.add_argument('--grad_accum', type=int, default=4)
    parser.add_argument('--num_workers', type=int, default=4)
    
    # 输出参数
    parser.add_argument('--output_dir', type=str, default='/data/yty/brats23_sam3_lora_output')
    parser.add_argument('--val_freq', type=int, default=5)
    parser.add_argument('--seed', type=int, default=42)
    
    args = parser.parse_args()
    
    # 设置随机种子
    torch.manual_seed(args.seed)
    np.random.seed(args.seed)
    
    device = setup_device()
    
    # 保存配置
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    with open(output_dir / 'config.json', 'w') as f:
        json.dump(vars(args), f, indent=2)
    
    # 创建数据集
    print(f"\n{'='*60}")
    print("Creating datasets...")
    print(f"{'='*60}")
    
    train_dataset = BraTSImageDataset(
        data_root=args.data_root,
        split='train',
        modality=args.modality,
        target_size=tuple(args.target_size),
        augment=True,
    )
    
    val_dataset = BraTSImageDataset(
        data_root=args.data_root,
        split='val',
        modality=args.modality,
        target_size=tuple(args.target_size),
        augment=False,
    )
    
    train_loader = DataLoader(
        train_dataset,
        batch_size=args.batch_size,
        shuffle=True,
        num_workers=args.num_workers,
        pin_memory=True,
        collate_fn=collate_fn_brats,
    )
    
    val_loader = DataLoader(
        val_dataset,
        batch_size=args.batch_size,
        shuffle=False,
        num_workers=args.num_workers,
        pin_memory=True,
        collate_fn=collate_fn_brats,
    )
    
    print(f"Train samples: {len(train_dataset)}")
    print(f"Val samples: {len(val_dataset)}")
    
    # 构建模型
    print(f"\n{'='*60}")
    print("Building SAM3 model...")
    print(f"{'='*60}")
    
    model = build_sam3_for_training(args.checkpoint, device=str(device))
    
    # 应用LoRA
    print(f"\nApplying LoRA (rank={args.lora_rank}, alpha={args.lora_alpha})...")
    
    target_modules = ['q_proj', 'k_proj', 'v_proj', 'out_proj', 'qkv', 'proj']
    
    model = apply_lora_to_model(
        model,
        rank=args.lora_rank,
        alpha=args.lora_alpha,
        dropout=args.lora_dropout,
        target_modules=target_modules,
    )
    
    # 冻结除LoRA和decoder外的参数
    for name, param in model.named_parameters():
        if 'lora_' in name or '_decoder' in name:
            param.requires_grad = True
        else:
            param.requires_grad = False
    
    # 统计参数
    param_stats = count_parameters(model)
    print(f"\nParameter statistics:")
    print(f"  Total: {param_stats['total']:,}")
    print(f"  Trainable: {param_stats['trainable']:,}")
    print(f"  Trainable ratio: {param_stats['trainable_ratio']:.4%}")
    
    # 创建优化器
    trainable_params = [p for p in model.parameters() if p.requires_grad]
    optimizer = torch.optim.AdamW(trainable_params, lr=args.lr, weight_decay=args.weight_decay)
    
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs, eta_min=args.lr * 0.01)
    
    # 创建训练器 (暂时禁用AMP以避免dtype问题)
    trainer = SAM3Trainer(
        model=model,
        train_loader=train_loader,
        val_loader=val_loader,
        optimizer=optimizer,
        scheduler=scheduler,
        device=device,
        output_dir=str(output_dir),
        use_amp=False,  # 禁用AMP
        grad_accum_steps=args.grad_accum,
    )
    
    # 开始训练
    trainer.train(num_epochs=args.epochs, val_freq=args.val_freq)


if __name__ == "__main__":
    main()