Struct AutoModel 

pub struct AutoModel { /* private fields */ }

AutoModel: Trained model with full metadata

This is the main user-facing type for trained models. It wraps the UniversalModel along with all the metadata from the training process.

Implementations

impl AutoModel

pub fn from_build_result(result: BuildResult) -> Self

Create an AutoModel from a BuildResult

pub fn train(df: &DataFrame, target_col: &str) -> Result<Self>

Train a model with default settings (the simplest API)

This is the recommended entry point for most users.

Example

let model = AutoModel::train(&df, "price")?;
let predictions = model.predict(&test_df)?;

pub fn train_quick(df: &DataFrame, target_col: &str) -> Result<Self>

Train with quick settings (minimal tuning, fast training)

pub fn train_thorough(df: &DataFrame, target_col: &str) -> Result<Self>

Train with thorough settings (extensive tuning, best accuracy)

pub fn train_with_mode( df: &DataFrame, target_col: &str, mode: BoostingMode, ) -> Result<Self>

Train with a specific mode (bypass auto-selection)

pub fn train_with_config( df: &DataFrame, target_col: &str, config: AutoConfig, ) -> Result<Self>

Train with custom configuration

pub fn predict(&self, df: &DataFrame) -> Result<Vec<f32>>

Predict on a DataFrame

Returns predictions as a Vec.

pub fn predict_linear_only(&self, df: &DataFrame) -> Result<Vec<f32>>

Predict using only the linear component (LinearThenTree mode only)

For fair comparison between linear-only and full LinearThenTree. Uses the same preprocessing pipeline as the full model.

Returns

• Ok(Vec<f32>): Linear-only predictions (base + linear model)
• Err: If model is not LinearThenTree mode

pub fn predict_binned(&self, dataset: &BinnedDataset) -> Vec<f32>

Predict on a BinnedDataset (for advanced users)

pub fn mode(&self) -> BoostingMode

Get the boosting mode that was used

pub fn mode_confidence(&self) -> Option<Confidence>

Get confidence in the mode selection

pub fn build_time(&self) -> Duration

Get total training time

pub fn phase_times(&self) -> &BuildPhaseTimes

Get time breakdown by phase

pub fn preprocessing_plan(&self) -> Option<&PreprocessingPlan>

Get the preprocessing plan that was applied

pub fn feature_plan(&self) -> Option<&FeaturePlan>

Get the feature engineering plan that was applied

pub fn column_profile(&self) -> Option<&DataFrameProfile>

Get the column profile from analysis

pub fn analysis(&self) -> Option<&DatasetAnalysis>

Get the dataset analysis result

pub fn ltt_tuning(&self) -> Option<&LttTuningResult>

Get LTT tuning result (if LTT mode was used)

pub fn tree_tuning(&self) -> Option<&TreeTuningResult>

Get tree tuning result (if PureTree/RandomForest mode was used)

pub fn num_trees(&self) -> usize

Get number of trees in the model

pub fn num_features(&self) -> usize

Get number of features

pub fn inner(&self) -> &UniversalModel

Get the underlying UniversalModel

pub fn config(&self) -> &UniversalConfig

Get the discovered UniversalConfig

This returns the config that AutoModel discovered through analysis and tuning. You can export this config to JSON and use it to retrain with UniversalModel directly.

pub fn summary(&self) -> String

Get a comprehensive summary of the training process

This shows the full “Smart Engineer” report explaining every decision

pub fn save_config(&self, path: impl AsRef<Path>) -> Result<()>

Export the discovered config to JSON

This saves the UniversalConfig that AutoModel discovered through analysis and tuning. You can load this config and use it to retrain with UniversalModel directly.

Example

// Train with AutoModel
let model = AutoModel::train(&df, "target")?;

// Export the discovered config
model.save_config("optimal_config.json")?;

// Later: Load and tweak the config
let config = UniversalConfig::load_json("optimal_config.json")?;
let tweaked = config.with_learning_rate(0.05); // Adjust as needed

// Retrain with the tweaked config
let new_model = UniversalModel::train(&dataset, tweaked, &loss_fn)?;

pub fn save(&self, path: impl AsRef<Path>) -> Result<()>

Save the trained model to a file

This saves the underlying UniversalModel (weights, trees, ensembles, etc.) for inference. The model can be loaded later using UniversalModel::load().

Example

// Train and save both config and model
let model = AutoModel::train(&df, "target")?;
model.save_config("config.json")?;      // For retraining with AutoML
model.save("model.rkyv")?;               // For inference

// Later: Load for inference only (not AutoML)
let loaded = UniversalModel::load("model.rkyv")?;
let preds = loaded.predict(&dataset)?;

pub fn update( &mut self, df: &DataFrame, additional_rounds: usize, ) -> Result<AutoModelUpdateReport>

Update the model with new training data (incremental learning)

This method continues training from the current model state:

1. Uses existing pipeline_state for consistent preprocessing
2. Updates the underlying UniversalModel with new trees
3. Preserves all configuration from original training

Arguments

• df - New data to train on (must have same columns as original)
• additional_rounds - Number of new boosting rounds (trees) to add

Example

// Train on January data
let mut model = AutoModel::train(&jan_df, "target")?;

// Update with February data (10 more trees)
let report = model.update(&feb_df, 10)?;
println!("{}", report);

// Save the updated model
model.save_trb("model.trb")?;

pub fn save_trb(&self, path: impl AsRef<Path>, description: &str) -> Result<()>

Save model to TRB (TreeBoost) incremental format

TRB format supports incremental updates without rewriting the entire file. Use this format when you plan to update the model with new data.

Example

model.save_trb("model.trb", "Initial training on January data")?;

pub fn save_trb_update( &self, path: impl AsRef<Path>, rows_trained: usize, description: &str, ) -> Result<()>

Append an update to an existing TRB file

This appends a new segment without rewriting the base model.

Arguments

• path - Path to existing .trb file
• rows_trained - Number of rows used in this update
• description - Description of this update

pub fn load_trb(path: impl AsRef<Path>, target_column: &str) -> Result<Self>

Load model from TRB format for continued training

This loads the base model and all updates, ready for further training. The returned AutoModel will have minimal metadata (no tuning results, etc.) but the underlying model and pipeline state are preserved.

Example

let mut model = AutoModel::load_trb("model.trb", "target")?;
model.update(&new_data, 10)?;

pub fn is_compatible_for_update(&self, df: &DataFrame) -> bool

Check if model is compatible with dataset for incremental update

pub fn model_mut(&mut self) -> &mut UniversalModel

Get mutable reference to the underlying UniversalModel

Trait Implementations

impl Debug for AutoModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.