3D-CNN模式识别入门指南：从理论到实践的关键步骤

1次阅读

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

在图像识别领域，2D 卷积神经网络（2D-CNN）已经取得了巨大成功。但当面对视频分析、医学影像（如 CT/MRI）、气象数据等具有时间或空间连续性的三维数据时，传统 2D-CNN 就显得力不从心了。

2D-CNN 的局限：只能处理单帧空间特征，无法捕捉帧间的时间关系或三维空间结构
3D-CNN 的优势：通过立方体卷积核同时提取时空特征，例如能识别视频中 ” 挥手 ” 的动作时序

数学上看，2D 卷积在 (x,y) 平面上滑动，而 3D 卷积在 (x,y,z) 立方体中操作：

# 2D 卷积公式（单通道）output[x,y] = ∑∑ input[x+i,y+j] * kernel[i,j] 

# 3D 卷积公式（单通道）output[x,y,z] = ∑∑∑ input[x+i,y+j,z+k] * kernel[i,j,k]

实际效果对比：

2D 卷积核：像一张纸在图片上滑动，输出仍是 2D 特征图
3D 卷积核：像魔方在数据体上移动，输出保留深度维度

下面以处理 3D MNIST 数据集（三维手写数字）为例，展示完整实现流程：

import torch
from torch.utils.data import Dataset

class MNIST3D(Dataset):
    def __init__(self, data_tensor, labels):
        """
        输入：data_tensor: (N,16,16,16) 的 3D 体素数据
          labels: (N,) 的数字标签
        """
        self.data = data_tensor.float()
        self.labels = labels.long()

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        # 添加通道维度 (C,D,H,W)
        return self.data[idx].unsqueeze(0), self.labels[idx]

import torch.nn as nn

class Simple3DCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(# 输入尺寸：(1,16,16,16)
            nn.Conv3d(1, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool3d(2),  # 输出(32,8,8,8)

            nn.Conv3d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool3d(2)   # 输出(64,4,4,4)
        )
        self.classifier = nn.Sequential(nn.Flatten(),
            nn.Linear(64*4*4*4, 256),
            nn.ReLU(),
            nn.Linear(256, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        return self.classifier(x)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Simple3DCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 注意输入张量维度应为 (batch, channel, depth, height, width)
for epoch in range(10):
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()