C++手搓CNN卷积神经网络：从零实现到性能优化实战

1次阅读

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

卷积神经网络（CNN）在计算机视觉领域的重要性不言而喻，从图像分类到目标检测，CNN 已经成为许多应用的核心组件。虽然 Python 和深度学习框架如 TensorFlow、PyTorch 提供了便捷的开发方式，但在某些场景下，C++ 实现具有不可替代的优势：

嵌入式设备部署：资源受限的环境需要轻量级、高效率的实现
实时性要求高的场景：如自动驾驶、工业检测等低延迟应用
学习底层原理：通过手写实现深入理解 CNN 的每个计算细节

现有深度学习框架和手写 C ++ 实现各有适用场景：

TensorRT/OpenCV 等框架
优点：高度优化，支持多种硬件加速
适用场景：快速原型开发，生产环境部署
手写 C ++ 实现
优点：无依赖，完全可控，可针对特定场景优化
适用场景：嵌入式系统，教学目的，性能关键的核心组件

卷积操作是 CNN 的核心，我们需要高效实现滑动窗口计算。关键点包括：

void convolve2D(const float* input, const float* kernel, float* output,
               int inWidth, int inHeight, int kernelSize) {
    int pad = kernelSize / 2;
    for (int y = pad; y < inHeight - pad; ++y) {for (int x = pad; x < inWidth - pad; ++x) {
            float sum = 0.0f;
            for (int ky = -pad; ky <= pad; ++ky) {for (int kx = -pad; kx <= pad; ++kx) {sum += input[(y + ky) * inWidth + (x + kx)] * 
                           kernel[(ky + pad) * kernelSize + (kx + pad)];
                }
            }
            output[y * inWidth + x] = sum;
        }
    }
}

边界处理通常采用零填充 (padding) 或镜像填充，这里我们使用零填充来保持特征图尺寸不变。

ReLU 激活函数 $f(x) = max(0, x)$ 看似简单，但通过 SIMD 指令可以大幅提升性能：

#include <immintrin.h>

void relu_avx(float* data, size_t size) {const __m256 zero = _mm256_setzero_ps();
    size_t i = 0;
    for (; i + 8 <= size; i += 8) {__m256 vec = _mm256_load_ps(data + i);
        __m256 mask = _mm256_cmp_ps(vec, zero, _CMP_GT_OS);
        __m256 result = _mm256_blendv_ps(zero, vec, mask);
        _mm256_store_ps(data + i, result);
    }
    // 处理剩余元素
    for (; i < size; ++i) {data[i] = data[i] > 0 ? data[i] : 0;
    }
}

使用 AVX 指令集，我们可以一次处理 8 个 float 数，理论上可以获得近 8 倍的加速。

频繁的内存分配释放会成为性能瓶颈，我们可以实现一个简单的内存池：

class Tensor {
public:
    Tensor(int width, int height) : w(width), h(height) {data = MemoryPool::alloc(w * h * sizeof(float));
    }
    ~Tensor() { MemoryPool::free(data); }
    // ... 其他方法
private:
    float* data;
    int w, h;
};

class MemoryPool {
public:
    static void* alloc(size_t size) {// 实现内存池分配逻辑}
    static void free(void* ptr) {// 实现内存池释放逻辑}
};

以下是一个简化版的 MNIST 分类实现框架：

class SimpleCNN {
public:
    SimpleCNN() {
        // 初始化卷积核权重 - Xavier 初始化
        float stddev = sqrt(2.0f / (KERNEL_SIZE * KERNEL_SIZE * 1));
        std::default_random_engine generator;
        std::normal_distribution<float> dist(0.0f, stddev);
        for (int i = 0; i < CONV1_OUT * KERNEL_SIZE * KERNEL_SIZE; ++i) {conv1_weights[i] = dist(generator);
        }
    }

    void forward(const float* input) {
        // 第一层卷积
        convolve2D(input, conv1_weights, conv1_output, 28, 28, 5);

        // ReLU 激活
        relu_avx(conv1_output, 28 * 28 * CONV1_OUT);

        // 最大池化
        maxPool2D(conv1_output, pool1_output, 28, 28, 2);

        // 全连接层...
    }

private:
    static const int KERNEL_SIZE = 5;
    static const int CONV1_OUT = 6;

    float conv1_weights[CONV1_OUT * KERNEL_SIZE * KERNEL_SIZE];
    float conv1_output[28 * 28 * CONV1_OUT];
    float pool1_output[14 * 14 * CONV1_OUT];
    // ... 其他层和参数
};

在 Intel i7-9700K 上测试 28×28 图像的前向传播：