Enum Booster 

pub enum Booster {
    Tree(SerializableTreeBooster),
    Linear(LinearBooster),
    LinearTree(LinearTreeBooster),
}

Unified booster enum for gradient boosting

Provides type-safe dispatch between different learner types while maintaining serialization compatibility.

Design

Uses enum dispatch instead of trait objects for:

• Zero-cost abstraction (no vtable overhead)
• rkyv serialization compatibility
• Compile-time optimization opportunities

Variants

Tree(SerializableTreeBooster)

Decision tree weak learner

Works on BinnedDataset. Best for:

• Capturing non-linear relationships
• Feature interactions
• Most tabular data problems

Linear(LinearBooster)

Linear model with Ridge regularization

Works on raw features. Best for:

• Capturing global trends
• Extrapolation beyond training range
• Time-series with drift

LinearTree(LinearTreeBooster)

Linear Tree: decision tree with linear models in leaves

Requires both BinnedDataset (for tree structure) and raw features (for linear models). Best for:

• 10-100x fewer trees than standard GBDT
• Capturing local linear relationships
• Smoother predictions

Implementations

impl Booster

pub fn tree(config: TreeConfig) -> Self

Create a new tree booster

pub fn linear(num_features: usize, config: LinearConfig) -> Self

Create a new linear booster

pub fn linear_tree(config: LinearTreeConfig) -> Self

Create a new linear tree booster

Linear trees combine decision tree partitioning with linear models in leaves. This requires both binned data (for tree structure) and raw features (for linear models).

pub fn fit_tree( &mut self, dataset: &BinnedDataset, gradients: &[f32], hessians: &[f32], row_indices: Option<&[usize]>, ) -> Result<()>

Fit tree booster on binned data

Errors

Returns TreeBoostError::Config if called on a Linear or LinearTree booster.

pub fn fit_linear( &mut self, features: &[f32], num_features: usize, gradients: &[f32], hessians: &[f32], ) -> Result<()>

Fit linear booster on raw features

Errors

Returns TreeBoostError::Config if called on a Tree or LinearTree booster.

pub fn fit_linear_tree( &mut self, dataset: &BinnedDataset, raw_features: &[f32], num_features: usize, gradients: &[f32], hessians: &[f32], ) -> Result<()>

Fit linear tree booster on binned data and raw features

Linear trees require both binned data (for tree structure) and raw features (for fitting linear models in each leaf).

Arguments

• dataset: Binned dataset for tree structure
• raw_features: Raw feature values (row-major: [row0_f0, row0_f1, …, row1_f0, …])
• num_features: Number of features
• gradients: Negative gradient of loss
• hessians: Second derivative of loss

Errors

Returns TreeBoostError::Config if called on a Tree or Linear booster.

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

Predict using tree booster on binned data

Returns zero vector if called on non-Tree booster.

pub fn predict_tree_add(&self, dataset: &BinnedDataset, predictions: &mut [f32])

Add tree predictions to existing buffer

No-op if called on non-Tree booster or if tree not fitted.

pub fn predict_linear(&self, features: &[f32], num_features: usize) -> Vec<f32>

Predict using linear booster on raw features

Returns zero vector if called on non-Linear booster.

pub fn predict_linear_tree( &self, dataset: &BinnedDataset, raw_features: &[f32], num_features: usize, ) -> Vec<f32>

Predict using linear tree booster on binned data and raw features

Returns zero vector if called on non-LinearTree booster.

pub fn predict_linear_tree_add( &self, dataset: &BinnedDataset, raw_features: &[f32], num_features: usize, predictions: &mut [f32], )

Add linear tree predictions to existing buffer

No-op if called on non-LinearTree booster.

pub fn is_tree(&self) -> bool

Check if this is a tree booster

pub fn is_linear(&self) -> bool

Check if this is a linear booster

pub fn is_linear_tree(&self) -> bool

Check if this is a linear tree booster

pub fn num_params(&self) -> usize

Get number of parameters

pub fn is_fitted(&self) -> bool

Check if the booster is fitted

pub fn as_tree(&self) -> Option<&Tree>

Get tree reference (if tree booster)

pub fn as_linear(&self) -> Option<&LinearBooster>

Get linear booster reference (if linear booster)

pub fn as_linear_tree(&self) -> Option<&LinearTreeBooster>

Get linear tree booster reference (if linear tree booster)

pub fn reset(&mut self)

Reset the booster to initial state

Trait Implementations

impl Archive for Booster

where SerializableTreeBooster: Archive, LinearBooster: Archive, LinearTreeBooster: Archive,

type Archived = ArchivedBooster

The archived representation of this type.

type Resolver = BoosterResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for Booster

fn clone(&self) -> Booster

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Booster

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Booster

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Booster, __D> for Archived<Booster>

where SerializableTreeBooster: Archive, <SerializableTreeBooster as Archive>::Archived: Deserialize<SerializableTreeBooster, __D>, LinearBooster: Archive, <LinearBooster as Archive>::Archived: Deserialize<LinearBooster, __D>, LinearTreeBooster: Archive, <LinearTreeBooster as Archive>::Archived: Deserialize<LinearTreeBooster, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Booster, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl From<LinearBooster> for Booster

fn from(booster: LinearBooster) -> Self

Converts to this type from the input type.

impl From<LinearTreeBooster> for Booster

fn from(booster: LinearTreeBooster) -> Self

Converts to this type from the input type.

impl From<TreeBooster> for Booster

fn from(booster: TreeBooster) -> Self

Converts to this type from the input type.

impl<__S: Fallible + ?Sized> Serialize<__S> for Booster

where SerializableTreeBooster: Serialize<__S>, LinearBooster: Serialize<__S>, LinearTreeBooster: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for Booster

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.