Rolling Statistics — Machine Learning/Feature Engineering

Rolling Statistics

Machine Learning / Feature Engineering

Reduces the last N samples of every channel to one number, elementwise: y[c] = stat( u[k][c], u[k−1][c], …, u[k−N+1][c] ), with the statistic chosen by configuration – mean, standard deviation, minimum, maximum or RMS.

This is the feature front end a deployed model needs: a classifier is almost never trained on a raw sample, but on a handful of windowed statistics of it. Feed several of these blocks from one signal and concatenate them to build the feature vector a Dense Layer or a Decision Tree expects.

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, any size [m,1]. Each of the m channels carries its own independent window; nothing is mixed across channels.
• y – the statistic, [m,1]: the same size as the input, one reduced value per channel. The reduction is over TIME, never over the vector – for a statistic across the entries of one sample use Sum Of Elements or MinMax instead.

Parameters

• Statistic – which reduction the window gets. Each is a different code path rather than a retuning of one, so each is verified as its own mode:
  • Mean – the arithmetic average, emitted as a sum times the constant 1/N.
  • Standard Deviation – the population form, dividing the squared deviations by N and not by N−1. That is what numpy.std gives by default and what Layer Normalization uses in this same library; a model fitted with pandas.rolling().std() (which defaults to N−1) expects the other one, and at small N the two differ materially – at N = 5 by 12%.
  • Minimum / Maximum – the extreme over the window, a chain of comparisons.
  • RMS – √(mean of the squares). Distinct from the standard deviation in that the mean is not removed first, so it carries the signal's DC level.
• Window Length – N, the number of samples the statistic is taken over, one or more. The window is a whole number of samples, so at a sampling time of T_s it spans N·T_s seconds. N = 1 makes every statistic the sample itself (and the standard deviation zero), which is legal and useless.
• Initial Window Value – what every slot of the window holds before the first sample arrives. The window is full from the very first step: this block does not produce a shorter average over the first N−1 samples the way pandas.rolling does, because 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. Set it to the signal's resting level if the first N steps matter to you.
• 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 is unrolled at export time – N and m are both known then – so no backend contains a loop bound, a modulo or a ring-buffer index, and each carries the N−1 stored samples in its own persistent form seeded with Initial Window Value.

The three HDL targets split by statistic, which is the one thing to know before exporting to hardware:

• Mean, Minimum and Maximum are genuine synthesizable Q16.16. The mean's 1/N is folded into a constant at export time and multiplied, so no divider appears in the datapath; the extremes are a chain of comparisons.
• Standard Deviation and RMS are simulation-only real arithmetic: both need a square root, which has no place in a Q16.16 datapath. They simulate correctly and quantize at the port boundary, and are not offered as synthesizable.

The reduction multiplies by the constant 1/N in every target, including the in-app solver, so the exported core and the simulation agree to the last bit rather than to within a division's rounding.

Simulink bridge

None, and here for a structural reason rather than a missing block. All six counterparts do exist in the installed DSP System Toolbox – dspstat3/Moving Average, Moving RMS, Moving Standard Deviation, Moving Maximum, Moving Minimum – but a catalog entry carries exactly one library path, while this block's statistics are five different Simulink blocks. Registering any one of them would export the other four as that one, silently, which is worse than reporting no equivalent. The bridge therefore reports the block, and it has no parity testbench, which is the documented consequence of that choice. Code export verification still covers it across all ten languages.

Notes

• Stateful: the same input gives a different output depending on the N−1 samples before it. The window is re-seeded at the start of every run.
• No state space, deliberately. The mean alone is linear, but the statistic is a configuration choice and the other four are not, so the block declines one in every mode rather than being mergeable in one of five.
• The state is read before it is written. The output is computed from the window as it stood, and only then does the window shift. The exported code shifts from the far end downwards for that reason – except on the three HDL targets, where the state is a registered signal and pre-clock reads give it for free.
• Not Tapped Delay, and not MinMax Running Resettable. The first emits the window itself and reduces nothing; the second runs since its last reset rather than over a window, so its answer never comes back down.