C++人工智能入门实战：从零构建你的第一个神经网络模型

1次阅读

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

作为系统级语言，C++ 在 AI 领域有独特优势：

性能优势：相比 Python，C++ 可以直接操作硬件资源，避免解释器开销
部署友好：编译后的二进制可脱离运行时环境独立部署
生态成熟：TensorFlow、PyTorch 等框架底层均依赖 C ++ 实现
资源控制：精准的内存管理和并行计算能力对大规模模型至关重要

当然，Python 在原型开发阶段更方便。但当遇到性能瓶颈或需要嵌入式部署时，C++ 是不二之选。

神经元：接收输入(x)、权重(w)、偏置(b)，输出output = activation(w*x + b)
激活函数：引入非线性（常用 ReLU：f(x)=max(0,x)）
反向传播：通过链式法则计算梯度，使用梯度下降更新参数

class Matrix {
public:
    Matrix(size_t rows, size_t cols) 
        : rows_(rows), cols_(cols), data_(rows * cols) {}

    // 使用移动语义优化临时对象
    Matrix(Matrix&& other) noexcept {
        rows_ = other.rows_;
        cols_ = other.cols_;
        data_ = std::move(other.data_);
    }

    // 启用 SIMD 的矩阵乘法
    Matrix operator*(const Matrix& rhs) {Matrix result(rows_, rhs.cols_);
        #pragma omp parallel for // 并行优化
        for(size_t i=0; i<rows_; ++i) {for(size_t k=0; k<cols_; ++k) {for(size_t j=0; j<rhs.cols_; ++j) {result(i,j) += (*this)(i,k) * rhs(k,j);
                }
            }
        }
        return result;
    }

private:
    std::vector<float> data_;
    size_t rows_, cols_;
};

class DenseLayer {
public:
    DenseLayer(size_t input_size, size_t output_size) 
        : weights_(input_size, output_size),
          biases_(1, output_size) {
        // Xavier 初始化防止梯度消失
        float scale = sqrt(2.0f/(input_size + output_size));
        std::normal_distribution<float> dist(0, scale);
        for(auto& val : weights_.data()) val = dist(gen);
    }

    Matrix forward(const Matrix& input) {
        // z = Wx + b
        Matrix output = input * weights_;
        output += biases_;

        // ReLU 激活
        for(auto& val : output.data()) 
            val = std::max(0.0f, val);
        return output;
    }

private:
    Matrix weights_, biases_;
    std::mt19937 gen{std::random_device{}()};
};

void train(Matrix& X_train, Matrix& y_train) {DenseLayer layer1(784, 128); // MNIST 输入 784 维
    DenseLayer layer2(128, 10);  // 输出 10 分类

    for(int epoch=0; epoch<100; ++epoch) {
        // 前向传播
        auto hidden = layer1.forward(X_train);
        auto output = layer2.forward(hidden);

        // 计算交叉熵损失
        float loss = cross_entropy(output, y_train);

        // 反向传播（伪代码）auto grad_output = output - y_train;
        auto grad_hidden = layer2.backward(grad_output);
        layer1.backward(grad_hidden);

        // 更新参数
        layer1.update(learning_rate);
        layer2.update(learning_rate);
    }
}