Struct SGBTLearner 

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

Adapter that wraps an SGBT ensemble into the StreamingLearner trait.

This is the primary way to use SGBT models in polymorphic stacking ensembles. The loss function L is monomorphized at compile time for zero-cost gradient dispatch, while the StreamingLearner trait provides the uniform interface needed by meta-learners.

Type Parameter

• L — loss function type, defaulting to SquaredLoss for regression. Any L: Loss + Clone is supported.

Examples

use irithyll::learner::SGBTLearner;
use irithyll::SGBTConfig;

// Default squared loss:
let config = SGBTConfig::builder().n_steps(5).build().unwrap();
let learner = SGBTLearner::from_config(config);

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

// Custom loss via wrapping an existing SGBT:
let config = SGBTConfig::builder().n_steps(5).build().unwrap();
let model = SGBT::with_loss(config, LogisticLoss);
let learner = SGBTLearner::new(model);

Implementations

impl<L: Loss> SGBTLearner<L>

pub fn new(model: SGBT<L>) -> Self

Wrap an existing SGBT model into a SGBTLearner.

The model retains all of its current state (trained trees, samples seen, etc.). This enables wrapping a partially-trained model.

pub fn inner(&self) -> &SGBT<L>

Immutable access to the underlying SGBT model.

Useful for inspecting model internals (config, base prediction, number of steps) without consuming the adapter.

pub fn inner_mut(&mut self) -> &mut SGBT<L>

Mutable access to the underlying SGBT model.

Enables calling SGBT-specific methods (e.g., predict_transformed, serialization) that are not part of the StreamingLearner interface.

pub fn into_inner(self) -> SGBT<L>

Consume the adapter and return the underlying SGBT model.

This is useful when you need to serialize the model or switch from polymorphic back to monomorphic usage.

impl SGBTLearner<SquaredLoss>

pub fn from_config(config: SGBTConfig) -> Self

Create a new SGBTLearner with squared loss from a configuration.

This is the most common constructor for regression tasks. For custom losses, construct the SGBT first with SGBT::with_loss and wrap it via SGBTLearner::new.

Examples

use irithyll::learner::{SGBTLearner, StreamingLearner};
use irithyll::SGBTConfig;

let config = SGBTConfig::builder()
    .n_steps(10)
    .learning_rate(0.05)
    .build()
    .unwrap();
let learner = SGBTLearner::from_config(config);
assert_eq!(learner.n_samples_seen(), 0);

Trait Implementations

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

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

Formats the value using the given formatter.

impl<L: Loss> StreamingLearner for SGBTLearner<L>

fn train_one(&mut self, features: &[f64], target: f64, weight: f64)

Train on a single observation with explicit sample weight.

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

Predict the target for the given feature vector.

fn n_samples_seen(&self) -> u64

Total number of observations trained on since creation or last reset.

fn reset(&mut self)

Reset the model to its initial (untrained) state.

fn train(&mut self, features: &[f64], target: f64)

Train on a single observation with unit weight.

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

Predict for each row in a feature matrix.