test_dA.cpp

#include "dA.h"
#include <chrono>
#include <iomanip>
#include <iostream>
#include <random>
#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;
}

// 添加一些异常值到数据中
std::vector<double> add_anomalies(const std::vector<double> &data,
                                  double anomaly_factor = 2.0) {
    std::vector<double> anomalous_data = data;
    static std::random_device rd;
    static std::mt19937 gen(rd());
    std::uniform_int_distribution<size_t> idx_dist(0, data.size() - 1);
    std::uniform_real_distribution<double> sign_dist(0, 1);

    // 随机选择几个维度添加异常值
    size_t num_anomalies = std::max(size_t(1), data.size() / 4);
    for (size_t i = 0; i < num_anomalies; ++i) {
        size_t idx = idx_dist(gen);
        double sign = sign_dist(gen) > 0.5 ? 1.0 : -1.0;
        anomalous_data[idx] = data[idx] + sign * anomaly_factor;
    }

    return anomalous_data;
}

// 打印向量
void print_vector(const std::vector<double> &vec, const std::string &name) {
    std::cout << name << ": [";
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << std::fixed << std::setprecision(4) << vec[i];
        if (i < vec.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << "]" << std::endl;
}

// 测试基本功能
void test_basic_functionality() {
    std::cout << "===== 测试基本功能 =====" << std::endl;

    // 创建自动编码器参数
    dA_params params(5, 3, 0.1, 0.2, 10);

    // 创建自动编码器
    dA autoencoder(params);

    // 生成随机训练数据
    std::vector<std::vector<double>> training_data;
    for (int i = 0; i < 100; ++i) {
        training_data.push_back(generate_random_data(5, 0.0, 1.0));
    }

    // 训练自动编码器
    std::cout << "训练自动编码器..." << std::endl;
    for (int epoch = 0; epoch < 50; ++epoch) {
        double avg_error = 0.0;
        for (const auto &data : training_data) {
            avg_error += autoencoder.train(data);
        }
        avg_error /= training_data.size();

        if (epoch % 10 == 0 || epoch == 49) {
            std::cout << "  Epoch " << epoch
                      << ": 平均重构误差 = " << std::fixed
                      << std::setprecision(6) << avg_error << std::endl;
        }
    }

    // 测试重构
    std::cout << "测试重构..." << std::endl;
    auto test_data = generate_random_data(5, 0.0, 1.0);
    print_vector(test_data, "原始数据");

    auto reconstructed = autoencoder.reconstruct(test_data);
    print_vector(reconstructed, "重构数据");

    double rmse = autoencoder.execute(test_data);
    std::cout << "重构误差 (RMSE): " << rmse << std::endl;

    // 测试异常检测
    std::cout << "测试异常检测..." << std::endl;
    auto normal_data = generate_random_data(5, 0.0, 1.0);
    auto anomalous_data = add_anomalies(normal_data, 3.0);

    print_vector(normal_data, "正常数据");
    print_vector(anomalous_data, "异常数据");

    double normal_rmse = autoencoder.execute(normal_data);
    double anomalous_rmse = autoencoder.execute(anomalous_data);

    std::cout << "正常数据重构误差: " << normal_rmse << std::endl;
    std::cout << "异常数据重构误差: " << anomalous_rmse << std::endl;
    std::cout << "异常分数比率: " << anomalous_rmse / normal_rmse << std::endl;
}

// 测试性能
void test_performance() {
    std::cout << "\n===== 测试性能 =====" << std::endl;

    // 创建较大维度的自动编码器
    const size_t input_dim = 100;
    const size_t hidden_dim = 50;
    const size_t num_samples = 1000;

    dA_params params(input_dim, hidden_dim, 0.01, 0.0, 10);
    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, 0.0, 1.0));
    }

    // 测量训练时间
    std::cout << "测量 " << num_samples << " 个样本的训练时间..." << std::endl;
    auto start_time = std::chrono::high_resolution_clock::now();

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

    auto end_time = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);

    std::cout << "训练 " << num_samples << " 个样本用时: " << duration.count()
              << " ms" << std::endl;
    std::cout << "平均每个样本训练时间: "
              << static_cast<double>(duration.count()) / num_samples << " ms"
              << std::endl;

    // 测量推理时间
    std::cout << "测量 " << num_samples << " 个样本的推理时间..." << std::endl;
    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();
    duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);

    std::cout << "推理 " << num_samples << " 个样本用时: " << duration.count()
              << " ms" << std::endl;
    std::cout << "平均每个样本推理时间: "
              << static_cast<double>(duration.count()) / num_samples << " ms"
              << std::endl;
}

int main() {
    // 测试基本功能
    test_basic_functionality();

    // 测试性能
    test_performance();

    return 0;
}