TensorLib 🔢 高性能C++张量计算库 v2.0

📖 系统概述

TensorLib v2.0 是一个基于C++17的高性能张量计算库，专为科学计算和机器学习设计。库采用现代C++技术，提供零开销抽象、编译时优化和SIMD向量化，性能远超Python生态。

✨ 核心特性

• 编译时形状检查 — 维度不匹配直接编译错误，零运行时开销
• 表达式模板 — 自动操作融合，消除临时对象，单次循环完成复合运算
• BLAS/LAPACK集成 — 高性能线性代数，支持OpenBLAS/MKL
• SIMD向量化 — AVX2/SSE2指令集，自动向量化循环
• OpenMP并行 — 多线程加速，支持CPU多核并行
• 内存池管理 — 减少内存分配开销，提高缓存命中率
• 自动微分 — 支持神经网络反向传播
• 文件IO — CSV、二进制格式读写，NumPy格式支持
• 音频处理 — WAV读写、梅尔频谱、FFT变换
• 图像处理 — 图像加载、增强、归一化

🏗️ 架构设计

⚡ 快速开始

#include "tensor.hpp"
using namespace tl;

int main() {
    // 创建张量
    Tensor A({3, 4}, 1.0f);
    Tensor B({4, 5}, 2.0f);
    
    // 矩阵乘法
    auto C = blas::matmul(A, B);
    std::cout << "C shape: " << C.shape().to_string() << std::endl;
    
    // 神经网络
    nn::Linear fc(784, 128);
    nn::ReLU relu;
    
    Tensor input({1, 784}, 0.5f);
    auto output = relu.forward(fc.forward(input));
    
    // PCA降维
    Tensor data = random::normal({1000, 50}, 0, 1);
    algorithms::PCA pca(10);
    auto transformed = pca.fit_transform(data);
    
    // K-Means聚类
    algorithms::KMeans kmeans(5);
    kmeans.fit(data);
    
    // 音频处理
    audio::MelSpectrogram mel(16000, 512, 40);
    auto features = mel.extract(test_audio);
    
    return 0;
}

📦 编译与依赖

依赖项: C++17编译器, CMake ≥3.15, OpenBLAS/MKL, LAPACK, FFTW3 (可选), libsndfile (可选)

# Ubuntu/Debian 安装依赖
sudo apt update
sudo apt install -y build-essential cmake \
    libopenblas-dev liblapack-dev liblapacke-dev \
    libfftw3-dev libsndfile1-dev libomp-dev

# 克隆仓库
git clone https://github.com/example/tensor_lib.git
cd tensor_lib

# 编译
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_EXAMPLES=ON
make -j$(nproc)

# 运行测试
./demos/mnist_train
./demos/audio_classifier

# 查看性能测试
./tensor_benchmark

🔢 张量核心

核心API

// 构造函数
Tensor<float> a({3, 4});                    // 3x4 零矩阵
Tensor<float> b({3, 4}, 1.0f);               // 3x4 全1矩阵
Tensor<float> c{1, 2, 3, 4};                 // 1D张量

// 元素访问
a(0, 1) = 3.14f;                            // 多维索引
float val = b[10];                          // 线性索引

// 形状操作
auto shape = a.shape();                     // 获取形状
auto reshaped = a.reshape({2, 6});          // 重塑
auto transposed = a.transpose();            // 转置
auto sliced = a.slice(0, 1, 3);             // 切片

// 数学运算
a.fill(2.0f);                               // 填充
a.zero();                                   // 清零
a.one();                                    // 置1

// 迭代器
for (auto& val : a) { val *= 2; }           // 范围循环

表达式模板

// 自动融合，单次循环完成
Tensor<float> Z = X * 2.0f + Y;             // 等价于: for(i) Z[i]=X[i]*2+Y[i]

// 无临时对象，零内存分配
auto expr = (A + B) * C - D;                // 构建表达式树
Tensor<float> result = expr;                // 单次循环求值

📐 线性代数

BLAS操作

// 矩阵乘法
auto C = blas::matmul(A, B);                 // C = A @ B

// 矩阵向量乘法
Tensor<float> y = blas::matvec(A, x);        // y = A * x

// 点积
float dot = blas::dot(x, y);                 // x·y

// 范数
float norm2 = blas::norm<2>(x);              // L2范数
float norm1 = blas::norm<1>(x);              // L1范数

LAPACK分解

// SVD分解
Tensor<float> U, S, VT;
linalg::svd(A, U, S, VT);                    // A = U * S * V^T

// QR分解
Tensor<float> Q, R;
linalg::qr(A, Q, R);                         // A = Q * R

// 特征值分解
Tensor<float> eigvals, eigvecs;
linalg::eig(A, eigvals, eigvecs);            // A * v = λ * v

// Cholesky分解
auto L = linalg::cholesky(A);                // A = L * L^T

// 线性方程组求解
auto x = linalg::solve(A, b);                // A * x = b

// 矩阵求逆
auto A_inv = linalg::inv(A);                 // A^{-1}

性能数据

🧠 神经网络

网络层

// 全连接层
nn::Linear<float> fc(784, 128);              // 输入784，输出128

// 卷积层
nn::Conv2d<float> conv(3, 64, 3, 1, 1);     // 输入3通道，输出64通道，3x3核

// 池化层
nn::MaxPool2d<float> pool(2, 2);            // 2x2最大池化

// Dropout
nn::Dropout<float> dropout(0.5f);            // 50% dropout

// 激活函数
nn::ReLU<float> relu;
nn::Sigmoid<float> sigmoid;
nn::Tanh<float> tanh;
nn::Softmax<float> softmax;

// 损失函数
nn::MSELoss<float> mse;
nn::CrossEntropyLoss<float> cross_entropy;

// 优化器
optim::SGD<float> sgd(0.01f, 0.9f);         // SGD with momentum
optim::Adam<float> adam(0.001f);             // Adam优化器

MNIST训练示例

// 构建网络
MLP model(784, 128, 10);
nn::CrossEntropyLoss<float> loss_fn;
optim::Adam<float> optimizer(0.001f);

// 训练循环
for (int epoch = 0; epoch < 10; ++epoch) {
    float epoch_loss = 0;
    for (auto& batch : train_loader) {
        // 前向传播
        auto logits = model.forward(batch.images);
        auto loss = loss_fn.forward(logits, batch.labels);
        
        // 反向传播
        auto grad = loss_fn.backward(logits, batch.labels);
        model.backward(grad);
        
        // 参数更新
        optimizer.step();
        optimizer.zero_grad();
        
        epoch_loss += loss[0];
    }
    std::cout << "Epoch " << epoch << " loss: " << epoch_loss << std::endl;
}

训练结果

🤖 机器学习算法

PCA主成分分析

algorithms::PCA<float> pca(50);              // 降到50维
pca.fit(data);                               // 拟合
auto transformed = pca.transform(data);      // 变换
auto reconstructed = pca.inverse_transform(transformed);  // 重建

// 查看解释方差
auto explained_var = pca.explained_variance_ratio();

K-Means聚类

algorithms::KMeans<float> kmeans(10);        // 10个簇
kmeans.fit(data);                            // 拟合
auto labels = kmeans.predict(data);          // 预测
auto centers = kmeans.centers();             // 获取簇中心
float inertia = kmeans.inertia();            // 簇内平方和

线性SVM

algorithms::LinearSVM<float> svm(1.0);       // C=1.0
svm.fit(X_train, y_train);                   // 训练
auto predictions = svm.predict(X_test);      // 预测

🎵 音频处理

梅尔频谱特征提取

audio::MelSpectrogram mel(16000, 512, 40);   // 采样率16k, FFT512, 40梅尔带
auto features = mel.extract(audio_signal);   // 提取特征

// 输出形状: [时间帧数, 40]

音频分类器

audio::AudioClassifier classifier(40, 128, 3);  // 40维输入，128隐藏，3类
int prediction = classifier.predict(features);   // 分类

WAV文件读写

audio::WavLoader::WavInfo info;
auto audio = audio::WavLoader::load_wav("speech.wav", info);
std::cout << "采样率: " << info.sample_rate << " Hz" << std::endl;
std::cout << "时长: " << info.duration << " 秒" << std::endl;

audio::WavLoader::save_wav(audio, "output.wav", 16000);

⚙️ 并行计算

OpenMP并行

// 自动并行化的矩阵乘法
#pragma omp parallel for collapse(2)
for (size_t i = 0; i < M; ++i) {
    for (size_t j = 0; j < N; ++j) {
        float sum = 0;
        for (size_t k = 0; k < K; ++k) {
            sum += A(i, k) * B(k, j);
        }
        C(i, j) = sum;
    }
}

SIMD向量化

// 使用SIMD指令集
simd::add(out, a, b, n);                     // AVX2/SSE2加速的向量加法
simd::scalar_multiply(out, a, scalar, n);    // 标量乘法

内存池

// 减少内存分配开销
MemoryPool<float> pool;
float* ptr1 = pool.allocate(1024);
float* ptr2 = pool.allocate(2048);
// 批量释放，避免碎片

📊 性能基准

矩阵乘法性能 (1024x1024)

机器学习算法性能

📌 示例程序

⚖️ 许可证