Struct BenchmarkTestData 

pub struct BenchmarkTestData {
    pub texts: Vec<&'static str>,
    pub semantic_pairs: Vec<(usize, usize, f32)>,
}

Test data for benchmarking

Fields

texts: Vec<&'static str>

semantic_pairs: Vec<(usize, usize, f32)>

Implementations

impl BenchmarkTestData

pub fn new_default() -> Self

Get default test data for benchmarking

Examples found in repository

examples/benchmark_hash.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔥 Manx Embedding Provider Benchmarks");
    println!("=====================================\n");

    // Test different hash dimensions
    let dimensions = vec![128, 256, 384, 512, 768];
    let test_data = BenchmarkTestData::new_default();
    let extended_data = BenchmarkTestData::extended();

    println!("📊 Testing Hash Provider with Different Dimensions");
    println!(
        "Test Data: {} texts with {} similarity pairs\n",
        test_data.texts.len(),
        test_data.semantic_pairs.len()
    );

    let mut results = Vec::new();

    for dim in &dimensions {
        let provider = HashProvider::new(*dim);
        let result = benchmark_provider(&provider, &test_data).await?;
        results.push(result);
    }

    print_benchmark_results(&results);

    println!("\n📈 Extended Dataset Benchmark (Hash-384)");
    println!(
        "Extended Data: {} texts with {} similarity pairs\n",
        extended_data.texts.len(),
        extended_data.semantic_pairs.len()
    );

    let provider_384 = HashProvider::new(384);
    let extended_result = benchmark_provider(&provider_384, &extended_data).await?;
    print_benchmark_results(&[extended_result]);

    println!("\n✅ Benchmark Complete!");
    println!("💡 Next: Compare with ONNX-based embeddings for quality improvements");

    Ok(())
}

pub fn extended() -> Self

Get extended test data for more comprehensive benchmarking

Examples found in repository

examples/benchmark_hash.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔥 Manx Embedding Provider Benchmarks");
    println!("=====================================\n");

    // Test different hash dimensions
    let dimensions = vec![128, 256, 384, 512, 768];
    let test_data = BenchmarkTestData::new_default();
    let extended_data = BenchmarkTestData::extended();

    println!("📊 Testing Hash Provider with Different Dimensions");
    println!(
        "Test Data: {} texts with {} similarity pairs\n",
        test_data.texts.len(),
        test_data.semantic_pairs.len()
    );

    let mut results = Vec::new();

    for dim in &dimensions {
        let provider = HashProvider::new(*dim);
        let result = benchmark_provider(&provider, &test_data).await?;
        results.push(result);
    }

    print_benchmark_results(&results);

    println!("\n📈 Extended Dataset Benchmark (Hash-384)");
    println!(
        "Extended Data: {} texts with {} similarity pairs\n",
        extended_data.texts.len(),
        extended_data.semantic_pairs.len()
    );

    let provider_384 = HashProvider::new(384);
    let extended_result = benchmark_provider(&provider_384, &extended_data).await?;
    print_benchmark_results(&[extended_result]);

    println!("\n✅ Benchmark Complete!");
    println!("💡 Next: Compare with ONNX-based embeddings for quality improvements");

    Ok(())
}

examples/benchmark_onnx_vs_hash.rs (line 24)

async fn main() -> Result<()> {
    // Initialize logging to see what's happening
    env_logger::builder()
        .filter_level(log::LevelFilter::Info)
        .init();

    println!("🚀 Manx Embedding Provider Performance Comparison");
    println!("================================================");
    println!("Comparing Hash vs ONNX-based embeddings\n");

    // Test data for comparison
    let test_data = BenchmarkTestData::extended();
    println!("📊 Test Dataset:");
    println!(
        "   {} texts with {} semantic similarity pairs",
        test_data.texts.len(),
        test_data.semantic_pairs.len()
    );

    println!("\n📋 Sample texts:");
    for (i, text) in test_data.texts.iter().take(3).enumerate() {
        println!("   {}. {}", i + 1, text);
    }
    println!("   ... and {} more", test_data.texts.len() - 3);

    println!("\n{}", "=".repeat(60));

    // Benchmark 1: Hash Provider (current baseline)
    println!("\n🔧 PHASE 1: Hash-based Embeddings (Baseline)");
    println!("---------------------------------------------");

    let hash_provider = HashProvider::new(384);
    let hash_result = benchmark_provider(&hash_provider, &test_data).await?;

    print_benchmark_results(std::slice::from_ref(&hash_result));

    // Benchmark 2: ONNX Provider (if available)
    println!("\n🤖 PHASE 2: ONNX-based Embeddings (Testing)");
    println!("--------------------------------------------");

    // Check if we need to download the model
    let model_name = "sentence-transformers/all-MiniLM-L6-v2";
    println!("📦 Checking for ONNX model: {}", model_name);

    // Note: In a real implementation, we'd download the model here
    // For now, we'll create a simulation to show what the comparison would look like
    println!("⚠️  ONNX model download not implemented in this demo");
    println!("    In production, this would:");
    println!("    1. Download {} from HuggingFace", model_name);
    println!("    2. Convert to ONNX format if needed");
    println!("    3. Load tokenizer and model files");
    println!("    4. Initialize ONNX Runtime session");

    // Simulate what ONNX results would look like based on research
    simulate_onnx_comparison(&hash_result).await?;

    println!("\n{}", "=".repeat(60));
    println!("\n📈 SUMMARY & RECOMMENDATIONS");
    println!("============================");

    print_recommendations(&hash_result);

    println!("\n✅ Benchmark Complete!");
    println!("\n💡 To enable real ONNX testing:");
    println!("   1. Implement model download from HuggingFace");
    println!("   2. Add ONNX model file handling");
    println!(
        "   3. Test with: cargo run --example benchmark_onnx_vs_hash --features onnx-embeddings"
    );

    Ok(())
}