Function evaluate_params

crates/openquant/src/hyperparameter_tuning.rs:387–425

(
    build_classifier: &F,
    params: &ParamSet,
    splits: &[(Vec<usize>, Vec<usize>)],
    x: &[Vec<f64>],
    y: &[f64],
    sample_weight: Option<&[f64]>,
    scoring: SearchScoring,
)

}

fn evaluate_params<C, F>(
    build_classifier: &F,
    params: &ParamSet,
    splits: &[(Vec<usize>, Vec<usize>)],
    x: &[Vec<f64>],
    y: &[f64],
    sample_weight: Option<&[f64]>,
    scoring: SearchScoring,
) -> Result<Vec<f64>, String>
where
    C: SimpleClassifier,
    F: Fn(&ParamSet) -> C,
{
    let mut fold_scores = Vec::with_capacity(splits.len());

    for (train_idx, test_idx) in splits {
        if train_idx.is_empty() || test_idx.is_empty() {
            return Err("PurgedKFold generated an empty train/test fold".to_string());
        }

        let x_train: Vec<Vec<f64>> = train_idx.iter().map(|i| x[*i].clone()).collect();
        let y_train: Vec<f64> = train_idx.iter().map(|i| y[*i]).collect();
        let x_test: Vec<Vec<f64>> = test_idx.iter().map(|i| x[*i].clone()).collect();
        let y_test: Vec<f64> = test_idx.iter().map(|i| y[*i]).collect();

        let sw_train: Option<Vec<f64>> =
            sample_weight.map(|sw| train_idx.iter().map(|i| sw[*i]).collect());
        let sw_test: Option<Vec<f64>> =
            sample_weight.map(|sw| test_idx.iter().map(|i| sw[*i]).collect());

        let mut clf = build_classifier(params);
        clf.fit(&x_train, &y_train, sw_train.as_deref());
        let probs = clf.predict_proba(&x_test);
        let fold_score = classification_score(&y_test, &probs, sw_test.as_deref(), scoring)?;
        fold_scores.push(fold_score);
    }

    Ok(fold_scores)
}