Python和MATLAB及Julia示例3D残差U-Net

🌵Python示例

在 Python 中实现 3D 残差 U-Net 涉及使用深度学习框架，如 PyTorch。3D 残差 U-Net 结合了 U-Net 的分割能力和残差网络的优势，适用于医学图像分割等需要处理三维数据的任务。下面是如何用 PyTorch 实现 3D 残差 U-Net 的详细代码。

步骤分解

我们将实现以下组件：

• 3D 卷积层：用于处理三维输入数据。
• 残差块：通过引入捷径连接，缓解梯度消失问题。
• U-Net 结构：包括下采样和上采样路径。
• 跳跃连接：在上采样阶段保留高分辨率特征。

代码实现

确保已安装 PyTorch，可以通过 pip install torch 安装。

import torch
import torch.nn as nn
import torch.nn.functional as F

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv3d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn1 = nn.BatchNorm3d(out_channels)
        self.conv2 = nn.Conv3d(out_channels, out_channels, kernel_size, stride, padding)
        self.bn2 = nn.BatchNorm3d(out_channels)
        
        # 如果输入和输出通道数不同，需要调整捷径
        if in_channels != out_channels:
            self.shortcut = nn.Conv3d(in_channels, out_channels, kernel_size=1)
        else:
            self.shortcut = nn.Identity()

    def forward(self, x):
        shortcut = self.shortcut(x)
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.bn2(self.conv2(x))
        x += shortcut
        return F.relu(x)

class UpConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(UpConv, self).__init__()
        self.up = nn.ConvTranspose3d(in_channels, out_channels, kernel_size=2, stride=2)

    def forward(self, x):
        return self.up(x)

class ResidualUNet3D(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(ResidualUNet3D, self).__init__()
        
        # 编码路径
        self.enc1 = ResidualBlock(in_channels, 64)
        self.pool1 = nn.MaxPool3d(2)
        self.enc2 = ResidualBlock(64, 128)
        self.pool2 = nn.MaxPool3d(2)
        self.enc3 = ResidualBlock(128, 256)
        self.pool3 = nn.MaxPool3d(2)
        self.enc4 = ResidualBlock(256, 512)

        # 瓶颈层
        self.bottleneck = ResidualBlock(512, 1024)

        # 解码路径
        self.up3 = UpConv(1024, 512)
        self.dec3 = ResidualBlock(1024, 512)
        self.up2 = UpConv(512, 256)
        self.dec2 = ResidualBlock(512, 256)
        self.up1 = UpConv(256, 128)
        self.dec1 = ResidualBlock(256, 128)
        self.final_conv = nn.Conv3d(128, out_channels, kernel_size=1)

    def forward(self, x):
        # 编码路径
        e1 = self.enc1(x)
        p1 = self.pool1(e1)
        e2 = self.enc2(p1)
        p2 = self.pool2(e2)
        e3 = self.enc3(p2)
        p3 = self.pool3(e3)
        e4 = self.enc4(p3)

        # 瓶颈层
        b = self.bottleneck(e4)

        # 解码路径
        d3 = self.up3(b)
        d3 = torch.cat((d3, e4), dim=1)
        d3 = self.dec3(d3)
        
        d2 = self.up2(d3)
        d2 = torch.cat((d2, e3), dim=1)
        d2 = self.dec2(d2)
        
        d1 = self.up1(d2)
        d1 = torch.cat((d1, e2), dim=1)
        d1 = self.dec1(d1)

        out = self.final_conv(d1)
        return out

# 示例实例化
model = ResidualUNet3D(in_channels=1, out_channels=2)
print(model)

代码解析

• 残差块：每个块包含两个 3D 卷积、批量归一化和 ReLU 激活。通过捷径连接缓解梯度消失问题。
• 上采样：UpConv 使用转置卷积进行上采样。
• 跳跃连接：在解码路径中将编码器对应层的输出拼接到解码器的输入，保持高分辨率信息。
• 输出层：通过 1x1 卷积将通道数降至所需的输出尺寸。

训练建议

• 使用适合 3D 数据的增强技术（如旋转、翻转）。
• 根据任务类型选择合适的损失函数，如 nn.CrossEntropyLoss() 或 nn.BCEWithLogitsLoss()。
• 使用 GPU 来提高处理三维数据的训练效率。

这段代码提供了一个可扩展的基础，可以根据具体的需求进行调整和改进。

🌵MATLAB示例

在 MATLAB 中实现 3D 残差 U-Net，涉及到构建自定义的深度学习网络结构。由于 MATLAB 提供了灵活的深度学习工具箱（如 Deep Learning Toolbox），我们可以使用它来实现 3D 卷积、残差模块和 U-Net 框架。下面是实现 3D 残差 U-Net 的关键步骤。

1. 基本构建块

• 残差模块：使用 3D 卷积层和批量归一化实现残差连接。
• 上采样层：通过转置卷积进行上采样。
• 跳跃连接：在下采样和上采样路径之间传递高分辨率特征。

2. 实现步骤

以下是一个在 MATLAB 中实现 3D 残差 U-Net 的示例代码：

function lgraph = create3DResUNet(inputSize, numClasses)
    layers = [
        image3dInputLayer(inputSize, 'Name', 'input')
        
        % Encoder Path
        convolution3dLayer(3, 64, 'Padding', 'same', 'Name', 'conv1_1')
        batchNormalizationLayer('Name', 'bn1_1')
        reluLayer('Name', 'relu1_1')
        convolution3dLayer(3, 64, 'Padding', 'same', 'Name', 'conv1_2')
        batchNormalizationLayer('Name', 'bn1_2')
        additionLayer(2, 'Name', 'add1')
        reluLayer('Name', 'relu1_2')
        maxPooling3dLayer(2, 'Stride', 2, 'Name', 'pool1')
        
        % Second Block
        convolution3dLayer(3, 128, 'Padding', 'same', 'Name', 'conv2_1')
        batchNormalizationLayer('Name', 'bn2_1')
        reluLayer('Name', 'relu2_1')
        convolution3dLayer(3, 128, 'Padding', 'same', 'Name', 'conv2_2')
        batchNormalizationLayer('Name', 'bn2_2')
        additionLayer(2, 'Name', 'add2')
        reluLayer('Name', 'relu2_2')
        maxPooling3dLayer(2, 'Stride', 2, 'Name', 'pool2')
        
        % Bottleneck
        convolution3dLayer(3, 256, 'Padding', 'same', 'Name', 'conv3_1')
        batchNormalizationLayer('Name', 'bn3_1')
        reluLayer('Name', 'relu3_1')
        convolution3dLayer(3, 256, 'Padding', 'same', 'Name', 'conv3_2')
        batchNormalizationLayer('Name', 'bn3_2')
        additionLayer(2, 'Name', 'add3')
        reluLayer('Name', 'relu3_2')
        
        % Decoder Path
        transposedConv3dLayer(2, 128, 'Stride', 2, 'Name', 'upconv2')
        depthConcatenationLayer(2, 'Name', 'concat2')
        convolution3dLayer(3, 128, 'Padding', 'same', 'Name', 'conv_dec2_1')
        batchNormalizationLayer('Name', 'bn_dec2_1')
        reluLayer('Name', 'relu_dec2_1')
        convolution3dLayer(3, 128, 'Padding', 'same', 'Name', 'conv_dec2_2')
        batchNormalizationLayer('Name', 'bn_dec2_2')
        additionLayer(2, 'Name', 'add_dec2')
        reluLayer('Name', 'relu_dec2_2')
        
        transposedConv3dLayer(2, 64, 'Stride', 2, 'Name', 'upconv1')
        depthConcatenationLayer(2, 'Name', 'concat1')
        convolution3dLayer(3, 64, 'Padding', 'same', 'Name', 'conv_dec1_1')
        batchNormalizationLayer('Name', 'bn_dec1_1')
        reluLayer('Name', 'relu_dec1_1')
        convolution3dLayer(3, 64, 'Padding', 'same', 'Name', 'conv_dec1_2')
        batchNormalizationLayer('Name', 'bn_dec1_2')
        additionLayer(2, 'Name', 'add_dec1')
        reluLayer('Name', 'relu_dec1_2')
        
        % Final Convolution
        convolution3dLayer(1, numClasses, 'Name', 'final_conv')
        softmaxLayer('Name', 'softmax')
        pixelClassificationLayer('Name', 'pixelClassLayer')
    ];
    
    lgraph = layerGraph(layers);
    
    % Adding skip connections
    lgraph = connectLayers(lgraph, 'relu1_1', 'add1/in2');
    lgraph = connectLayers(lgraph, 'relu2_1', 'add2/in2');
    lgraph = connectLayers(lgraph, 'relu3_1', 'add3/in2');
    lgraph = connectLayers(lgraph, 'relu_dec2_1', 'add_dec2/in2');
    lgraph = connectLayers(lgraph, 'relu_dec1_1', 'add_dec1/in2');
    lgraph = connectLayers(lgraph, 'conv1_2', 'concat1/in2');
    lgraph = connectLayers(lgraph, 'conv2_2', 'concat2/in2');
end

3. 代码解释

• 残差块：每个块由两个卷积层和批量归一化层组成。残差连接使用 additionLayer 实现。
• 上采样：transposedConv3dLayer 用于放大特征图。
• 跳跃连接：在下采样和上采样路径之间添加跳跃连接，以保留高分辨率特征。

4. 使用示例

调用 create3DResUNet 函数以创建网络图：

inputSize = [64, 64, 64, 1]; % 输入尺寸 (深度, 高度, 宽度, 通道)
numClasses = 2; % 输出类别数
lgraph = create3DResUNet(inputSize, numClasses);

% 可视化网络结构
analyzeNetwork(lgraph);

5. 训练网络

使用 trainNetwork 函数来训练网络，提供 3D 数据和标签。

% 假设数据集已经被设置为datastore格式
options = trainingOptions('adam', ...
    'MaxEpochs', 50, ...
    'InitialLearnRate', 1e-3, ...
    'MiniBatchSize', 4, ...
    'Plots', 'training-progress');

net = trainNetwork(trainingData, lgraph, options);

此实现可以根据需要进行扩展，如调整通道数或添加正则化层等。

👉更新：亚图跨际