Struct SGBT 

pub struct SGBT<L: Loss = SquaredLoss> { /* private fields */ }

Available on crate feature alloc only.

Streaming Gradient Boosted Trees ensemble.

The primary entry point for training and prediction. Generic over L: Loss so the loss function’s gradient/hessian calls are monomorphized (inlined) into the boosting hot loop – no virtual dispatch overhead.

The default type parameter L = SquaredLoss means SGBT::new(config) creates a regression model without specifying the loss type explicitly.

Examples

use irithyll::{SGBTConfig, SGBT};

// Regression with squared loss (default):
let config = SGBTConfig::builder().n_steps(10).build().unwrap();
let model = SGBT::new(config);

use irithyll::{SGBTConfig, SGBT};
use irithyll::loss::logistic::LogisticLoss;

// Classification with logistic loss -- no Box::new()!
let config = SGBTConfig::builder().n_steps(10).build().unwrap();
let model = SGBT::with_loss(config, LogisticLoss);

Implementations

impl SGBT<SquaredLoss>

pub fn new(config: SGBTConfig) -> Self

Create a new SGBT ensemble with squared loss (regression).

This is the most common constructor. For classification or custom losses, use with_loss.

impl<L: Loss> SGBT<L>

pub fn with_loss(config: SGBTConfig, loss: L) -> Self

Create a new SGBT ensemble with a specific loss function.

The loss is stored by value (monomorphized), giving zero-cost gradient/hessian dispatch.

use irithyll::{SGBTConfig, SGBT};
use irithyll::loss::logistic::LogisticLoss;

let config = SGBTConfig::builder().n_steps(10).build().unwrap();
let model = SGBT::with_loss(config, LogisticLoss);

pub fn train_one(&mut self, sample: &impl Observation)

Train on a single observation.

Accepts any type implementing Observation, including Sample, SampleRef, or tuples like (&[f64], f64) for zero-copy training.

pub fn train_batch<O: Observation>(&mut self, samples: &[O])

Train on a batch of observations.

pub fn train_batch_with_callback<O: Observation, F: FnMut(usize)>( &mut self, samples: &[O], interval: usize, callback: F, )

Train on a batch with periodic callback for cooperative yielding.

pub fn train_batch_subsampled<O: Observation>( &mut self, samples: &[O], max_samples: usize, )

Train on a random subsample of a batch using reservoir sampling (Algorithm R).

pub fn train_batch_subsampled_with_callback<O: Observation, F: FnMut(usize)>( &mut self, samples: &[O], max_samples: usize, interval: usize, callback: F, )

Train on a batch with both subsampling and periodic callbacks.

pub fn predict(&self, features: &[f64]) -> f64

Predict the raw output for a feature vector.

Uses auto-calibrated per-feature bandwidths for smooth (soft) routing. Falls back to hard routing before any training has occurred.

pub fn predict_smooth(&self, features: &[f64], bandwidth: f64) -> f64

Predict using sigmoid-blended soft routing with an explicit bandwidth.

pub fn auto_bandwidths(&self) -> &[f64]

Per-feature auto-calibrated bandwidths used by predict().

pub fn predict_interpolated(&self, features: &[f64]) -> f64

Predict with parent-leaf linear interpolation.

pub fn predict_sibling_interpolated(&self, features: &[f64]) -> f64

Predict with sibling-based interpolation for feature-continuous predictions.

pub fn predict_graduated(&self, features: &[f64]) -> f64

Predict with graduated active-shadow blending.

pub fn predict_graduated_sibling_interpolated(&self, features: &[f64]) -> f64

Predict with graduated blending + sibling interpolation.

pub fn predict_transformed(&self, features: &[f64]) -> f64

Predict with loss transform applied (e.g., sigmoid for logistic loss).

pub fn predict_proba(&self, features: &[f64]) -> f64

Predict probability (alias for predict_transformed).

pub fn predict_with_confidence(&self, features: &[f64]) -> (f64, f64)

Predict with confidence estimation.

Returns (prediction, confidence) where confidence = 1 / sqrt(sum_variance).

pub fn predict_batch(&self, feature_matrix: &[Vec<f64>]) -> Vec<f64>

Batch prediction.

pub fn n_steps(&self) -> usize

Number of boosting steps.

pub fn n_trees(&self) -> usize

Total trees (active + alternates).

pub fn total_leaves(&self) -> usize

Total leaves across all active trees.

pub fn n_samples_seen(&self) -> u64

Total samples trained.

pub fn base_prediction(&self) -> f64

The current base prediction.

pub fn is_initialized(&self) -> bool

Whether the base prediction has been initialized.

pub fn config(&self) -> &SGBTConfig

Access the configuration.

pub fn set_learning_rate(&mut self, lr: f64)

Set the learning rate for future boosting rounds.

pub fn steps(&self) -> &[BoostingStep]

Immutable access to the boosting steps.

pub fn loss(&self) -> &L

Immutable access to the loss function.

pub fn feature_importances(&self) -> Vec<f64>

Feature importances based on accumulated split gains across all trees.

Returns normalized importances (sum to 1.0) indexed by feature.

pub fn feature_names(&self) -> Option<&[String]>

Feature names, if configured.

pub fn named_feature_importances(&self) -> Option<Vec<(String, f64)>>

Feature importances paired with their names.

Returns None if feature names are not configured. Otherwise returns (name, importance) pairs sorted by importance descending.

pub fn train_one_named(&mut self, features: &HashMap<String, f64>, target: f64)

Available on crate feature std only.

Train on a single sample with named features.

pub fn predict_named(&self, features: &HashMap<String, f64>) -> f64

Available on crate feature std only.

Predict with named features.

pub fn reset(&mut self)

Reset the ensemble to initial state.

Trait Implementations

impl<L: Loss + Clone> Clone for SGBT<L>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Loss> Debug for SGBT<L>

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

Formats the value using the given formatter.