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

1次阅读

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

当决定用 C ++ 从头实现 CNN 时，我们立即面临几个关键挑战。多维数组处理首当其冲——图像数据、卷积核、特征图都是高维结构，而 C ++ 标准库缺乏原生支持。动态内存分配频繁带来的性能问题和内存碎片也令人头疼。计算图构建需要设计灵活的层间连接机制，这对静态类型语言是个考验。

更具体的挑战包括：

卷积运算中频繁的内存访问导致 cache 命中率低下
手动内存管理容易引发泄漏或越界
缺乏现成的自动微分机制
多线程环境下资源竞争问题

我们对比了三种主流实现方式，在 Core i7-11800H 上对 100 次 3×3 卷积运算进行基准测试：

实现方式	执行时间 (ms)	内存占用 (MB)
原生指针 + 循环	152.3	6.2
std::vector	178.6	8.7
Eigen 库	165.4	12.1

测试结果表明：

原生指针方案性能最优，但开发复杂度最高
std::vector 安全性更好，但存在约 17% 性能损失
Eigen 库矩阵运算方便，但内存开销较大

/**
 * @tparam T 数据类型
 * @tparam Dims 维度数量
 */
template <typename T, size_t Dims>
class Tensor {
public:
    explicit Tensor(const std::array<size_t, Dims>& shape) {
        // 计算总元素数并分配内存
        size_t total = 1;
        for (auto dim : shape) total *= dim;
        data_.reset(new T[total]);
        strides_.fill(1);

        // 计算步长 (内存布局优化关键)
        for (int i = Dims-2; i >=0; --i) {strides_[i] = strides_[i+1] * shape[i+1];
        }
    }

    // 多维索引访问
    T& operator()(const std::array<size_t, Dims>& indices) {
        size_t offset = 0;
        for (size_t i = 0; i < Dims; ++i) {offset += indices[i] * strides_[i];
        }
        return data_[offset];
    }

private:
    std::unique_ptr<T[]> data_;
    std::array<size_t, Dims> strides_;
};

卷积运算的核心公式：

$$(I * K)(x,y) = \sum_{i=-a}^a \sum_{j=-b}^b I(x+i, y+j) \cdot K(i,j)$$

边界处理采用零填充策略：

// 卷积运算核心代码
void convolve(const Tensor<float, 3>& input, 
              const Tensor<float, 3>& kernel,
              Tensor<float, 3>& output) {const int pad_h = kernel.shape()[0] / 2;
    const int pad_w = kernel.shape()[1] / 2;

    for (int c = 0; c < input.shape()[2]; ++c) {for (int h = 0; h < output.shape()[0]; ++h) {for (int w = 0; w < output.shape()[1]; ++w) {
                float sum = 0;

                for (int kh = 0; kh < kernel.shape()[0]; ++kh) {for (int kw = 0; kw < kernel.shape()[1]; ++kw) {
                        int ih = h + kh - pad_h;
                        int iw = w + kw - pad_w;

                        if (ih >= 0 && ih < input.shape()[0] && 
                            iw >= 0 && iw < input.shape()[1]) {sum += input(ih, iw, c) * kernel(kh, kw, c);
                        }
                    }
                }
                output(h, w, c) = sum;
            }
        }
    }
}

使用 AVX2 指令集实现向量化 ReLU：

#include <immintrin.h>

void relu_avx2(float* data, size_t size) {const __m256 zero = _mm256_setzero_ps();
    size_t i = 0;

    // 处理对齐部分
    for (; i + 7 < size; i += 8) {__m256 vec = _mm256_load_ps(data + i);
        __m256 mask = _mm256_cmp_ps(vec, zero, _CMP_GT_OQ);
        __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;
    }
}

测试显示，当卷积核尺寸为 16 字节对齐时，性能提升 23%：

// 分配对齐内存
float* kernel = static_cast<float*>(_mm_malloc(kernel_size * sizeof(float), 32));
// 使用后释放
_mm_free(kernel);

对小尺寸卷积核 (3×3)，展开内层循环
对多 batch 处理，采用 NHWC 内存布局
使用__builtin_prefetch 预取数据

采用 Kahan 求和算法减少累积误差：

float kahanSum(const float* data, size_t size) {
    float sum = 0.0f;
    float c = 0.0f; // 补偿项

    for (size_t i = 0; i < size; ++i) {float y = data[i] - c;
        float t = sum + y;
        c = (t - sum) - y;
        sum = t;
    }
    return sum;
}

在 MNIST 测试集上的结果对比：