Struct HalvingRandomSearchCV 

pub struct HalvingRandomSearchCV {
    pub param_distributions: ParameterDistributions,
    pub n_candidates: usize,
    pub cv: Box<dyn CrossValidator>,
    pub scoring: Scoring,
    pub factor: f64,
    pub resource: String,
    pub max_resource: Option<usize>,
    pub min_resource: Option<usize>,
    pub aggressive_elimination: bool,
    pub random_state: Option<u64>,
    pub n_jobs: Option<i32>,
}

Randomized search with successive halving for efficient hyperparameter optimization

HalvingRandomSearchCV is similar to HalvingGridSearch but samples parameter values randomly from distributions, making it more efficient for continuous parameter spaces.

Fields

param_distributions: ParameterDistributions

Parameter distributions to sample from

n_candidates: usize

Number of parameter settings that are sampled

cv: Box<dyn CrossValidator>

Cross-validation strategy

scoring: Scoring

Scoring function

factor: f64

The ‘halving’ parameter, which determines the proportion of candidates that are selected for each subsequent iteration

resource: String

The amount of resource that gets allocated to each candidate at the first iteration

max_resource: Option<usize>

The maximum amount of resource that any candidate can be allocated

min_resource: Option<usize>

The minimum amount of resource that any candidate can be allocated

aggressive_elimination: bool

Whether to use aggressive elimination strategy in the first iteration

random_state: Option<u64>

Random state for reproducible results

n_jobs: Option<i32>

Number of jobs for parallel execution

Implementations

impl HalvingRandomSearchCV

pub fn new(param_distributions: ParameterDistributions) -> Self

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

Set the number of candidates to sample

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

Set the halving factor

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_elimination: bool) -> Self

Set aggressive elimination strategy

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

Set the random state

pub fn n_jobs(self, n_jobs: i32) -> Self

Set the number of parallel jobs

pub fn fit_regression<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 random search for regression

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 random search for classification