Struct PredictionModel 

pub struct PredictionModel<A: Float + Send + Sync> { /* private fields */ }

Autoregressive prediction model for streaming data, fitted online.

The model is a vector autoregression with shared scalar coefficients: the next observation vector is predicted from the previous model_order observed vectors as

x[t] ~= a_1 * x[t-1] + a_2 * x[t-2] + ... + a_p * x[t-p] + b

with one scalar coefficient per lag plus an intercept, shared across all coordinates. Sharing the coefficients keeps the parameter count independent of the feature dimensionality (so a wide stream does not need a quadratic number of parameters to be trainable from a short window) while still capturing the temporal structure — trends, decay and oscillation — that a “repeat the last value” predictor cannot represent at all.

Fitting uses exponentially-weighted Recursive Least Squares: every observed coordinate of every new sample performs one exact rank-1 update of the least-squares solution, so the model is always the exact (forgetting-weighted) least-squares fit of everything it has seen. That is what makes it converge in a handful of periods rather than needing a learning-rate schedule.

Implementations

impl<A: Float + Send + Sync> PredictionModel<A>

pub fn new(model_order: usize) -> Result<Self>

Create a model of the given autoregressive order with the default forgetting factor.

Note that the argument is the autoregressive order (number of lags). The previous signature took a “feature dimension” and sized the never-trained weight vector with it; the real feature dimensionality is now adopted from the data on the first observation.

pub fn with_forgetting_factor( model_order: usize, forgetting_factor: A, ) -> Result<Self>

Create a model with an explicit exponential forgetting factor.

pub fn train_updates(&self) -> usize

Number of RLS updates applied so far (one per observed coordinate of every sample that had a full lag window available).

pub fn coefficients(&self) -> &Array1<A>

The fitted autoregressive coefficients [a_1, ..., a_p, b].

pub fn mean_absolute_error(&self) -> A

EWMA of the absolute one-step-ahead prediction error measured on live data before each sample was used for training, i.e. an honest out-of-sample error estimate.

pub fn normalized_error(&self) -> A

Measured out-of-sample error relative to the observed signal scale. Zero for an untrained model (it has made no errors yet because it has made no predictions).

pub fn confidence(&self) -> A

Confidence in [0, 1], derived from the measured out-of-sample error relative to the observed signal scale: 1 / (1 + error / scale). An untrained model reports zero — it has no basis for any claim.

pub fn observe(&mut self, point: &StreamingDataPoint<A>) -> Result<()>

Feed one newly observed data point to the model: measure the out-of-sample error of the prediction the current weights would have made for it, then perform the RLS update that folds it into the fit.

Must be called once per sample, in arrival order.

pub fn predict( &self, data: &VecDeque<StreamingDataPoint<A>>, horizon: usize, ) -> Result<Vec<StreamingDataPoint<A>>>

Roll the fitted model forward horizon steps from data, feeding each prediction back in as the next lag (the standard iterated multi-step forecast).

Returns fewer than horizon points when the model has not been trained yet, when data is shorter than the autoregressive order, or when the recursion stops producing finite values — never a fabricated copy of the present.