Autocorrelation Features — Machine Learning/Feature Engineering

Autocorrelation Features

Machine Learning / Feature Engineering

Correlates the last N samples of the signal with a delayed copy of itself, at each of a configured set of lags. With x[0] the current sample and x[k] the sample k steps back:

r(l) = Σ_k (x[k] − m)(x[k+l] − m) ÷ Σ_k (x[k] − m)²  – or the unnormalized covariance form, as a mode.

This is the cheap answer to "does this signal repeat, and after how long": a rotating machine's period, a gait cycle or a control loop's oscillation all show up as a peak at the lag that matches them, using multiplies and adds alone where a spectrum needs a transform. Feed the outputs to a Dense Layer or a Decision Tree as features.

Stateful and discrete by nature. The window advances one sample per step and has no derivative to integrate, so the block declares itself discrete-only and always steps at its own rate.

Ports

• u – the input sample, a scalar [1,1]. The lags index TIME, so one block follows one channel; use one block per channel and a Mux to gather the features.
• r – the correlations, [L,1], one entry per configured lag and in the order the lags are written. The height follows the Lags list, so the block resizes its output when you change it.

Parameters

• Window Length – N, the number of samples the correlation is taken over. Every lag is measured inside this one window, so a lag of l leaves N−l overlapping pairs to average: keep N several times the largest lag, or the longest lags rest on a handful of products.
• Lags – the lags to report, as a vector such as [1; 2; 3]. Each is a whole number of samples from 0 to N−1; lag 0 is the window's own energy (and is exactly 1 in the Coefficient form, which makes it a useful shape check and a useless feature).
• Normalization – what the products are divided by. The two are different code paths rather than a scaling, so each is verified as its own mode:
  • Coefficient – divided by the window's own sum of squared deviations, so every entry lies in [−1, 1] and is comparable across signals of different amplitude. This is what statsmodels.acf returns.
  • Covariance – the products averaged over N and nothing more, so the result keeps the signal's units squared. Use it when amplitude is itself a feature.
• Remove Mean – whether the window's mean is subtracted before correlating. On is the usual choice and what the formulas above show; with Off, a signal with a large DC level correlates strongly with itself at every lag and the shape of the curve is buried under it.
• Initial Window Value – what every slot holds before the first sample arrives. The window is full from the very first step rather than growing, for the reason Rolling Statistics gives: a partial window costs a sample counter and a divide-by-count branch in all ten exported languages, for a startup transient a feature pipeline discards anyway.
• Epsilon – a floor on the Coefficient form's denominator. A window that is exactly constant has zero variance and no defined correlation; the floor makes that case return zero in all ten languages instead of a division by zero. It is a floor and not a branch deliberately – the same choice Normalizer makes, and for the same reason: one expression every target has a primitive for, rather than an if-statement re-implemented eleven times.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period. Being discrete-only, a non-positive value falls back to the model's global sampling time rather than to the surrounding rate.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The window and every lag's product sum are unrolled at export time – N and the lag list are both known then – so no backend carries a loop bound, a modulo or a ring-buffer index, and each holds the N−1 stored samples in its own persistent form seeded with Initial Window Value.

The three HDL targets split by normalization: Covariance is genuine synthesizable Q16.16 – multiply-accumulate with the 1/N folded into a constant at export time, so no divider appears – while Coefficient divides by the window's own variance, a signal-dependent divisor that cannot be precomputed, and is therefore emitted as simulation-only real arithmetic. That mode simulates correctly and quantizes at the port boundary; it is not offered as synthesizable.

Simulink bridge

None. dspstat3/Autocorrelation exists in the installed DSP System Toolbox, but it emits the whole sequence up to a maximum lag, while this block reports a chosen SET of lags – there is no parameter on it that a Lags list maps onto, and an entry claiming otherwise would export a different function under this block's name. The bridge reports the block rather than dropping it silently, and it has no parity testbench, which is the documented consequence of Support::None. Code export verification still covers it across all ten languages.

Notes

• Stateful: the answer depends on the N−1 samples before the current one. The window is re-seeded at the start of every run.
• No state space: the correlation is quadratic in the input, so no A/B/C/D describes it and model reduction correctly refuses the block.
• The state is read before it is written. Every lag is computed from the window as it stood, and only then does the window shift – on the three HDL targets that comes free from the registered write, and the other seven shift from the far end downwards.
• Not a spectrum. For frequency content use FFT Magnitude; this block answers periodicity with no transform, which is what makes it affordable on a PLC or in fixed point.