Struct DriftAwareModel 

pub struct DriftAwareModel<M, D, A>
where
    D: DriftDetector,
    A: DriftStrategy,
{ /* private fields */ }

A wrapper that feeds prediction errors to a drift detector and applies the strategy’s action when drift is detected.

The wrapper is generic over the model M, detector D, and strategy A to avoid trait-object overhead and preserve concrete types. See the module documentation for the full contract.

Examples

use rill_ml::drift::{
    DriftAction, DriftAwareModel, PageHinkley, StaticStrategy,
};
use rill_ml::models::{BaselineConfig, MeanRegressor};

let model = MeanRegressor::new(BaselineConfig::default()).unwrap();
let detector = PageHinkley::default();
let strategy = StaticStrategy::new(DriftAction::NotifyOnly, DriftAction::ResetModel);
let mut aware = DriftAwareModel::new(model, detector, strategy);

// Stable stream: no events.
for i in 0..50 {
    let x = [i as f64 * 0.1];
    aware.learn(&x, 1.0).unwrap();
}
assert!(aware.events().is_empty());

Implementations

impl<M, D, A> DriftAwareModel<M, D, A>

where M: OnlineRegressor, D: DriftDetector, A: DriftStrategy,

pub fn new(model: M, detector: D, strategy: A) -> Self

Create a new drift-aware model with the default event log capacity (1000 entries).

pub fn with_max_events( model: M, detector: D, strategy: A, max_events: usize, ) -> Result<Self, RillError>

Create a new drift-aware model with a custom event log capacity.

Returns an error if max_events is zero.

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

Predict the target for the given features.

This is a pure delegation to the wrapped model’s predict and does not update any state.

pub fn learn(&mut self, features: &[f64], target: f64) -> Result<(), RillError>

Update the model using a single labeled sample.

The learning sequence is:

1. Predict with the current model (no state change).
2. Feed the absolute prediction error to the drift detector.
3. Ask the strategy for the response action.
4. If the detector reported a change, record a DriftEvent.
5. If the action is ResetModel, reset the wrapped model.
6. Learn from the sample.

pub const fn model(&self) -> &M

Borrow the wrapped model.

pub const fn detector(&self) -> &D

Borrow the wrapped detector.

pub const fn strategy(&self) -> &A

Borrow the wrapped strategy.

pub fn events(&self) -> &[DriftEvent]

The recorded drift events, oldest first.

The returned slice is guaranteed to be contiguous. When the event log exceeds max_events, the oldest entries are dropped.

pub const fn last_action(&self) -> Option<DriftAction>

The most recent action taken by the wrapper, or None if learn has not been called yet.

pub const fn samples_seen(&self) -> u64

The number of samples processed by learn.

pub const fn max_events(&self) -> usize

The maximum number of retained drift events.

pub fn reset(&mut self)

Reset the model, detector, and event log to their initial states.

The strategy is not reset (it is typically stateless). The max_events capacity is preserved.

Trait Implementations

impl<M: Clone, D, A> Clone for DriftAwareModel<M, D, A>

where D: DriftDetector + Clone, A: DriftStrategy + Clone,

fn clone(&self) -> DriftAwareModel<M, D, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug, D, A> Debug for DriftAwareModel<M, D, A>

where D: DriftDetector + Debug, A: DriftStrategy + Debug,

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

Formats the value using the given formatter.