Struct ParallelSGBT 

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

Parallel SGBT ensemble with delayed gradient updates.

All boosting steps train concurrently using the full ensemble prediction for gradient computation. Predictions remain sequential (deterministic) – only training is parallelized.

Generic over L: Loss so the loss function’s gradient/hessian calls are monomorphized (inlined) into the training loop — no virtual dispatch.

Differences from SGBT

Aspect	SGBT	ParallelSGBT
Gradient target	Rolling (step-by-step)	Full ensemble prediction
Step training	Sequential	Parallel (rayon)
Prediction	Sequential	Sequential (identical)
Convergence	Optimal	Slightly delayed
Throughput	1x	~Nx (N = cores)

Implementations

impl ParallelSGBT<SquaredLoss>

pub fn new(config: SGBTConfig) -> Self

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

impl<L: Loss> ParallelSGBT<L>

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

Create a new parallel SGBT ensemble with a specific loss function.

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

use irithyll::SGBTConfig;
use irithyll::ensemble::parallel::ParallelSGBT;
use irithyll::loss::logistic::LogisticLoss;

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

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

Train on a single observation using delayed gradient updates.

Accepts any type implementing Observation, including Sample, SampleRef, or tuples like (&[f64], f64).

All boosting steps receive the same gradient/hessian computed from the full ensemble prediction, then train in parallel (when the parallel feature is enabled).

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

Train on a batch of observations.

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

Predict the raw output for a feature vector.

Prediction is always sequential and deterministic, regardless of whether training uses parallelism.

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_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 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. Returns an empty Vec if no splits have occurred yet.

pub fn reset(&mut self)

Reset the ensemble to initial state.

Trait Implementations

impl<L: Loss + Clone> Clone for ParallelSGBT<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 ParallelSGBT<L>

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

Formats the value using the given formatter.