Struct HalvingGridSearch 

pub struct HalvingGridSearch<X, Y> { /* private fields */ }

HalvingGridSearch implementation

Uses successive halving to efficiently search hyperparameter spaces by progressively eliminating poor-performing candidates using increasing amounts of resources (typically training samples).

Example

use sklears_model_selection::{HalvingGridSearch, KFold, ParameterDistribution};
use scirs2_core::ndarray::array;
///
let X = array![[1.0, 2.0], [2.0, 3.0], [3.0, 3.0], [2.0, 1.0]];
let y = array![1.5, 2.5, 3.0, 1.8];

// Create parameter distributions
let mut param_distributions = HashMap::new();
param_distributions.insert("fit_intercept".to_string(),
    ParameterDistribution::Choice(vec![true.into(), false.into()]));

let search: HalvingGridSearch<scirs2_core::ndarray::Array2`<f64>`, scirs2_core::ndarray::Array1`<f64>`> = HalvingGridSearch::new(param_distributions)
    .n_candidates(8)
    .factor(2.0)
    .cv(Box::new(KFold::new(3)))
    .random_state(42);

// let results = search.fit(LinearRegression::new(), &X, &y);

Implementations

impl<X, Y> HalvingGridSearch<X, Y>

pub fn new(param_distributions: ParameterDistributions) -> Self

Create a new HalvingGridSearch

pub fn n_candidates(self, n_candidates: usize) -> Self

Set the number of initial candidates

pub fn factor(self, factor: f64) -> Self

Set the reduction factor for successive halving

pub fn cv(self, cv: Box<dyn CrossValidator>) -> Self

Set the cross-validation strategy

pub fn scoring(self, scoring: Scoring) -> Self

Set the scoring function

pub fn resource(self, resource: String) -> Self

Set the resource parameter

pub fn max_resource(self, max_resource: usize) -> Self

Set the maximum resource

pub fn min_resource(self, min_resource: usize) -> Self

Set the minimum resource

pub fn aggressive_elimination(self, aggressive: bool) -> Self

Enable or disable aggressive elimination

pub fn random_state(self, seed: u64) -> Self

Set random state for reproducibility

impl HalvingGridSearch<Array2<f64>, Array1<f64>>

pub fn fit<E, F>( &self, base_estimator: E, x: &Array2<f64>, y: &Array1<f64>, ) -> Result<HalvingGridSearchResults>

where E: Estimator + Clone + Fit<Array2<f64>, Array1<f64>, Fitted = F>, F: Predict<Array2<f64>, Array1<f64>>,

Fit the halving grid search for regression

impl HalvingGridSearch<Array2<f64>, Array1<i32>>

pub fn fit_classification<E, F>( &self, base_estimator: E, x: &Array2<f64>, y: &Array1<i32>, ) -> Result<HalvingGridSearchResults>

where E: Estimator + Clone + Fit<Array2<f64>, Array1<i32>, Fitted = F>, F: Predict<Array2<f64>, Array1<i32>>,

Fit the halving grid search for classification