perf_compare.cpp

#include "dA.h"
#include <chrono>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <random>
#include <string>
#include <vector>

// 生成随机数据
std::vector<double> generate_random_data(size_t size, double min_val = 0.0,
                                         double max_val = 1.0) {
    static std::random_device rd;
    static std::mt19937 gen(rd());
    std::uniform_real_distribution<double> dist(min_val, max_val);

    std::vector<double> data(size);
    for (auto &val : data) {
        val = dist(gen);
    }

    return data;
}

// 测试不同输入维度的C++版dA性能
void test_cpp_performance(const std::vector<size_t> &input_sizes,
                          double hidden_ratio = 0.75, size_t num_samples = 1000,
                          size_t epochs = 1) {
    std::vector<double> train_times;
    std::vector<double> inference_times;

    for (const auto &input_dim : input_sizes) {
        size_t hidden_dim =
            static_cast<size_t>(std::ceil(input_dim * hidden_ratio));

        // 创建自动编码器
        dA_params params(input_dim, hidden_dim, 0.01, 0.0, 0);
        dA autoencoder(params);

        // 生成随机训练数据
        std::vector<std::vector<double>> training_data;
        for (size_t i = 0; i < num_samples; ++i) {
            training_data.push_back(generate_random_data(input_dim));
        }

        // 测量训练时间
        auto start_time = std::chrono::high_resolution_clock::now();

        for (size_t e = 0; e < epochs; ++e) {
            for (const auto &data : training_data) {
                autoencoder.train(data);
            }
        }

        auto end_time = std::chrono::high_resolution_clock::now();
        auto train_duration =
            std::chrono::duration_cast<std::chrono::microseconds>(end_time -
                                                                  start_time);
        double train_time = train_duration.count() / 1000000.0; // 转换为秒
        train_times.push_back(train_time);

        // 测量推理时间
        start_time = std::chrono::high_resolution_clock::now();

        for (const auto &data : training_data) {
            autoencoder.execute(data);
        }

        end_time = std::chrono::high_resolution_clock::now();
        auto inference_duration =
            std::chrono::duration_cast<std::chrono::microseconds>(end_time -
                                                                  start_time);
        double inference_time =
            inference_duration.count() / 1000000.0; // 转换为秒
        inference_times.push_back(inference_time);

        // 输出结果
        std::cout << "C++ dA - 输入维度: " << input_dim
                  << ", 隐藏层维度: " << hidden_dim << std::endl;
        std::cout << "  训练 " << num_samples << " 个样本 x " << epochs
                  << " epochs 用时: " << std::fixed << std::setprecision(4)
                  << train_time << " 秒" << std::endl;
        std::cout << "  平均每个样本训练时间: "
                  << train_time * 1000 / (num_samples * epochs) << " ms"
                  << std::endl;
        std::cout << "  推理 " << num_samples
                  << " 个样本用时: " << inference_time << " 秒" << std::endl;
        std::cout << "  平均每个样本推理时间: "
                  << inference_time * 1000 / num_samples << " ms" << std::endl;
        std::cout << std::string(50, '-') << std::endl;
    }

    // 保存结果
    std::ofstream outfile("cpp_perf_results.txt");
    outfile << "input_sizes = [";
    for (size_t i = 0; i < input_sizes.size(); ++i) {
        outfile << input_sizes[i];
        if (i < input_sizes.size() - 1)
            outfile << ", ";
    }
    outfile << "]\n";

    outfile << "cpp_train_times = [";
    for (size_t i = 0; i < train_times.size(); ++i) {
        outfile << train_times[i];
        if (i < train_times.size() - 1)
            outfile << ", ";
    }
    outfile << "]\n";

    outfile << "cpp_inference_times = [";
    for (size_t i = 0; i < inference_times.size(); ++i) {
        outfile << inference_times[i];
        if (i < inference_times.size() - 1)
            outfile << ", ";
    }
    outfile << "]\n";

    outfile << "num_samples = " << num_samples << "\n";
    outfile << "epochs = " << epochs << "\n";
    outfile.close();

    std::cout << "结果已保存到 cpp_perf_results.txt" << std::endl;
}

int main() {
    // 测试不同输入维度
    std::vector<size_t> input_sizes = {10, 50, 100, 200, 500};
    size_t num_samples = 1000;
    size_t epochs = 1;

    std::cout << "===== C++ dA性能测试 =====" << std::endl;
    test_cpp_performance(input_sizes, 0.5, num_samples, epochs);

    return 0;
}