searchi/crates/searchi-semantic/tests/cpu_model.rs

//! Opt-in real-artifact test. Default tests never acquire model/runtime assets.
#![cfg(feature = "minilm-proof")]
use searchi_semantic::{CpuEmbedder, DIMENSIONS};
use std::path::PathBuf;

#[test]
#[ignore = "Requires explicit SEARCHI_MODEL_DIR and SEARCHI_ORT_LIBRARY local assets"]
fn real_cpu_model_retrieves_english_and_german_fixture() {
    let model =
        PathBuf::from(std::env::var_os("SEARCHI_MODEL_DIR").expect("Set SEARCHI_MODEL_DIR"));
    let runtime =
        PathBuf::from(std::env::var_os("SEARCHI_ORT_LIBRARY").expect("Set SEARCHI_ORT_LIBRARY"));
    let fixture: serde_json::Value =
        serde_json::from_str(include_str!("../../../tools/semantic-proof/fixture.json")).unwrap();
    let documents = fixture["documents"].as_array().unwrap();
    let texts: Vec<_> = documents
        .iter()
        .map(|doc| doc["text"].as_str().unwrap())
        .collect();
    let mut embedder = CpuEmbedder::load(&model, &runtime, 1).unwrap();
    let vectors = embedder.encode(&texts).unwrap();
    assert!(vectors.iter().all(|vector| vector.len() == DIMENSIONS));
    for vector in &vectors {
        let norm = vector.iter().map(|v| v * v).sum::<f32>().sqrt();
        assert!((norm - 1.0).abs() < 1e-5);
    }
    let mut correct = 0;
    for query in fixture["queries"].as_array().unwrap() {
        let vector = embedder
            .encode(&[query["text"].as_str().unwrap()])
            .unwrap()
            .remove(0);
        let mut scores: Vec<_> = vectors
            .iter()
            .enumerate()
            .map(|(i, candidate)| {
                (
                    i,
                    candidate
                        .iter()
                        .zip(&vector)
                        .map(|(a, b)| a * b)
                        .sum::<f32>(),
                )
            })
            .collect();
        scores.sort_by(|a, b| b.1.total_cmp(&a.1));
        let rank = scores
            .iter()
            .position(|(i, _)| documents[*i]["id"] == query["expected"])
            .unwrap()
            + 1;
        println!(
            "{}: expected rank {rank}; top result {}",
            query["language"], documents[scores[0].0]["id"]
        );
        assert!(
            rank <= 3,
            "Real model lost expected passage for {}",
            query["text"]
        );
        correct += usize::from(rank == 1);
    }
    // This is the measured proof baseline, not the production quality gate.
    // A known product-release query currently returns the expected result second.
    assert!(
        correct >= 5,
        "Semantic proof regressed below measured 5/6 top-1 baseline"
    );
    assert!(embedder.encode(&[" "]).is_err());
    assert!(embedder.encode(&["x"; 9]).is_err());
}