Brats2020数据集实战指南：从数据预处理到3D脑肿瘤分割模型训练

1次阅读

共计 2229 个字符，预计需要花费 6 分钟才能阅读完成。

Brats2020 作为脑胶质瘤分割的权威数据集，包含多模态 MRI（T1、T1ce、T2、FLAIR）和精细的肿瘤子区域标注（坏死区、水肿区、增强肿瘤）。其技术挑战主要体现在：

多模态数据对齐 ：不同扫描序列间存在空间位移
标注复杂性 ：肿瘤子区域呈现层级关系（如增强肿瘤包含在肿瘤核心区内）
数据异构性 ：各医院扫描仪参数差异导致强度分布不一致

from monai.transforms import N4BiasFieldCorrection
# 需安装 ANTs 后端：pip install antspyx
n4_transform = N4BiasFieldCorrection(
    dim=3,
    spline_order=3,
    shrink_factor=4,
    convergence_threshold=1e-5,
)

模态间标准化 ：对每个模态单独做 Z -score
空间归一化 ：统一重采样到 1mm³各向同性分辨率

import numpy as np
def normalize_modality(data):
    """
    data: [H,W,D] 的 3D 体数据
    返回: 去噪后标准化数据
    """
    mask = data > data.mean()  # 简单脑组织掩膜
    masked_data = data[mask]
    return (data - masked_data.mean()) / masked_data.std()

空间变换 ：随机旋转 (±15°)、弹性变形
模态 dropout：模拟缺失模态（概率 10%）
强度扰动 ：Gamma 变换 (γ∈[0.7,1.5])

import torch.nn as nn

class ResAttBlock(nn.Module):
    def __init__(self, in_ch):
        super().__init__()
        self.conv = nn.Sequential(nn.Conv3d(in_ch, in_ch, 3, padding=1),
            nn.InstanceNorm3d(in_ch),
            nn.ReLU(),)
        self.att = nn.Sequential(nn.AdaptiveAvgPool3d(1),
            nn.Conv3d(in_ch, in_ch//8, 1),
            nn.ReLU(),
            nn.Conv3d(in_ch//8, in_ch, 1),
            nn.Sigmoid())

    def forward(self, x):
        residual = x
        x = self.conv(x)
        att = self.att(x)
        return residual + x * att

def dice_loss(pred, target, weights=[1,2,3]):
    """
    pred: [B,C,D,H,W] 经过 softmax
    target: [B,D,H,W] 类别标签
    weights: 各类别权重（水肿 / 坏死 / 增强肿瘤）"""
    smooth = 1e-5
    pred = pred.float()
    target = nn.functional.one_hot(target, num_classes=4).permute(0,4,1,2,3)

    intersection = (pred * target).sum(dim=(2,3,4))
    union = pred.sum(dim=(2,3,4)) + target.sum(dim=(2,3,4))

    dice = (2. * intersection + smooth) / (union + smooth)
    weighted_loss = (1 - dice[:,1:]) * torch.tensor(weights).to(pred.device)  # 忽略背景类
    return weighted_loss.mean()

梯度累积 ：每 4 个 batch 更新一次参数
混合精度训练 ：使用 torch.cuda.amp 自动管理

scaler = torch.cuda.amp.GradScaler()

for epoch in range(100):
    optimizer.zero_grad()

    # 累计梯度
    for i, batch in enumerate(dataloader):
        with torch.cuda.amp.autocast():
            outputs = model(batch['image'])
            loss = dice_loss(outputs, batch['label'])

        scaler.scale(loss/4).backward()

        if (i+1) % 4 == 0:
            scaler.step(optimizer)
            scaler.update()
            optimizer.zero_grad()