Struct AdaptiveSGBT 

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

Available on crate feature alloc only.

SGBT ensemble with an attached learning rate scheduler.

Before each train_one call, AdaptiveSGBT:

1. Computes the current prediction to estimate loss.
2. Queries the scheduler for the new learning rate.
3. Sets the learning rate on the inner SGBT.
4. Delegates the actual training step.

This allows any LRScheduler – exponential decay, cosine annealing, plateau reduction – to drive the ensemble’s learning rate without touching the core boosting logic.

Loss Estimation

The scheduler receives squared error (target - prediction)² as its loss signal. This is computed from the current ensemble prediction before the training step, making it a one-step-lagged estimate. This works well for schedulers like PlateauLR that smooth over many steps.

Implementations

impl AdaptiveSGBT<SquaredLoss>

pub fn new(config: SGBTConfig, scheduler: impl LRScheduler + 'static) -> Self

Create an adaptive SGBT with squared loss (regression).

The initial learning rate is taken from the config and also stored as base_lr for reference.

use irithyll::ensemble::adaptive::AdaptiveSGBT;
use irithyll::ensemble::lr_schedule::ConstantLR;
use irithyll::SGBTConfig;

let config = SGBTConfig::builder()
    .n_steps(10)
    .learning_rate(0.05)
    .build()
    .unwrap();
let model = AdaptiveSGBT::new(config, ConstantLR::new(0.05));

impl<L: Loss> AdaptiveSGBT<L>

pub fn with_loss( config: SGBTConfig, loss: L, scheduler: impl LRScheduler + 'static, ) -> Self

Create an adaptive SGBT with a specific loss function.

use irithyll::ensemble::adaptive::AdaptiveSGBT;
use irithyll::ensemble::lr_schedule::LinearDecayLR;
use irithyll::loss::logistic::LogisticLoss;
use irithyll::SGBTConfig;

let config = SGBTConfig::builder()
    .n_steps(10)
    .learning_rate(0.1)
    .build()
    .unwrap();
let model = AdaptiveSGBT::with_loss(
    config, LogisticLoss, LinearDecayLR::new(0.1, 0.001, 10_000),
);

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

Train on a single observation, adapting the learning rate first.

This is the generic version accepting any Observation implementor. For the StreamingLearner trait interface, use train_one(features, target, weight).

pub fn current_lr(&self) -> f64

Current learning rate (as last set by the scheduler).

pub fn base_lr(&self) -> f64

The initial learning rate from the original config.

pub fn step_count(&self) -> u64

Total scheduler steps (equal to samples trained).

pub fn last_loss(&self) -> f64

Most recent loss value passed to the scheduler.

pub fn scheduler(&self) -> &dyn LRScheduler

Immutable access to the scheduler.

pub fn scheduler_mut(&mut self) -> &mut dyn LRScheduler

Mutable access to the scheduler.

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

Immutable access to the inner SGBT model.

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

Mutable access to the inner SGBT model.

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

Consume the wrapper and return the inner SGBT model.

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

Predict using the inner SGBT model.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<L: Loss> StreamingLearner for AdaptiveSGBT<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.