Struct AutoBuilder 

pub struct AutoBuilder { /* private fields */ }

AutoBuilder: High-level AutoML interface

Implementations

impl AutoBuilder

pub fn new() -> Self

Create a new AutoBuilder with default configuration

pub fn with_config(config: AutoConfig) -> Self

Create with custom configuration

pub fn with_tuning(self, level: TuningLevel) -> Self

Set tuning level

pub fn with_validation_split(self, ratio: f32) -> Self

Set validation split ratio

pub fn with_auto_features(self, enabled: bool) -> Self

Enable/disable automatic features

pub fn with_mode(self, mode: BoostingMode) -> Self

Force a specific mode

pub fn with_ensemble(self) -> Self

Enable ensemble training with default settings (PureTree only)

pub fn with_ensemble_method(self, method: AutoEnsembleMethod) -> Self

Enable ensemble training with a specific method (PureTree only)

pub fn with_ensemble_config(self, config: AutoEnsembleConfig) -> Self

Set full ensemble configuration (PureTree only)

pub fn with_verbose(self, verbose: bool) -> Self

Enable verbose output

pub fn with_time_budget(self, budget: Duration) -> Self

Set time budget for training

AutoBuilder will adapt its behavior to fit within this time limit:

• Skips feature engineering if time is tight (< 20s remaining)
• Reduces tuning intensity if time is limited (< 30s → Quick tuning)
• Skips tuning entirely if very low on time (< 10s)

Example

use std::time::Duration;
let builder = AutoBuilder::new()
    .with_time_budget(Duration::from_secs(60));  // 1 minute max

pub fn with_progress_callback(self, callback: Arc<dyn ProgressCallback>) -> Self

Set progress callback for tracking training phases

Example

use treeboost::model::ConsoleProgress;
use std::sync::Arc;

let builder = AutoBuilder::new()
    .with_progress_callback(Arc::new(ConsoleProgress::detailed()));

pub fn with_linear_feature_config(self, config: LinearFeatureConfig) -> Self

Set custom feature extractor configuration for LinearThenTree mode

This controls which features are extracted for the linear component. By default, all features are included (no exclusions).

Example

use treeboost::dataset::feature_extractor::LinearFeatureConfig;

let feature_config = LinearFeatureConfig::default()
    .with_exclude_categorical(true)  // Exclude categorical features from linear model
    .with_exclude_id(true);          // Exclude ID columns

let builder = AutoBuilder::new()
    .with_linear_feature_config(feature_config);

pub fn fit(&self, df: &DataFrame, target_col: &str) -> Result<BuildResult>

Fit the model on a Polars DataFrame

This is the main entry point. It:

1. Profiles the DataFrame
2. Determines preprocessing strategy
3. Plans feature engineering
4. Analyzes for mode selection
5. Tunes hyperparameters
6. Trains the final model

Trait Implementations

impl Default for AutoBuilder

fn default() -> Self

Returns the “default value” for a type.