Normalizer — Machine Learning/Preprocessing

Normalizer

Machine Learning / Preprocessing

Scales each sample to unit norm: y = u ÷ ‖u‖. It is scikit-learn's Normalizer at inference, the preprocessing step a model wants when only the direction of a feature vector carries information and its magnitude does not – a spectrum, a histogram, a bag of counts, or any signal whose overall gain drifts with the sensor.

Unlike the other scalers in this family it divides by a statistic of the current sample rather than by a fitted constant, so it needs no training output at all: there is nothing to paste in but the choice of norm.

Ports

• u – the feature column, [m,1]. Any m ≥ 1; the block reads the width from the signal rather than from a parameter, because the norm is taken over whatever arrives.
• Output – y, the same [m,1] shape. Its norm is 1 under the selected measure, except for the floored case below.

Parameters

• Norm – which measure is driven to 1.
  • L2 – y = u ÷ √(Σ uᵢ²), the Euclidean norm. The default, and what Normalizer() uses unless told otherwise.
  • L1 – y = u ÷ Σ |uᵢ|. On a non-negative vector this turns counts into proportions that sum to 1.
  • Max – y = u ÷ max |uᵢ|, which puts the largest entry at ±1 and leaves the rest inside it.
• Epsilon – a floor on the divisor: the block divides by max(‖u‖, Epsilon) rather than by the norm itself, so a zero or near-zero vector gives a finite answer instead of an infinity. It is one expression with no branch in it, which is what keeps all ten targets identical. On a zero vector this agrees exactly with scikit-learn (both give y = 0); it differs only for a vector whose norm is tiny but nonzero, which scikit-learn amplifies to unit length and this block does not. Raise it if your input has a noise floor you do not want stretched.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The selected norm and Epsilon are baked into the generated code at export time; there is no tunable parameter, because changing the norm changes which arithmetic is emitted rather than a value it uses.

The three HDL targets are simulation-only, and this block cannot be made synthesizable the way Standard Scaler is: that block divides by a fitted constant, which can be inverted once at export time so the datapath only multiplies, whereas this one divides by a value that is not known until the sample arrives. The bodies read the port with to_real, compute in real, and quantize back with to_fx – the same pattern Recursive IIR and Dense Layer use. They simulate correctly and are not offered for synthesis.

Simulink bridge

None – but unlike the rest of this family, not because nothing comparable exists. DSP System Toolbox is installed here and ships Normalization (dspmathops/Normalization). It was checked rather than assumed, and it computes a different function:

• Its NormType offers a 2-norm and a squared 2-norm only. That covers this block's L2 and neither L1 nor Max, so a model configured for one of those would export as a 2-norm without saying so – exactly what a bridge exists to prevent.
• It divides by (norm + Bias) where this block divides by max(norm, Epsilon). Those agree only where neither term binds, so Epsilon cannot be mapped onto Bias even for the L2 case.
• It normalizes down each column (or row, or a named dimension) of a frame, whereas this block treats the input as one sample.

If your pipeline only ever uses the L2 norm, you can substitute that block directly: set its Bias to 0 and keep the input a single column. The bridge reports this block rather than dropping it silently, and it has no parity testbench, which is the documented consequence of Support::None rather than a gap. Code export verification still covers it across all ten languages.

Notes

• Algebraic and stateless: the output depends only on the current sample, so the block cannot break an algebraic loop.
• Not elementwise. The norm reduces over the whole vector before any element is written, so entry i of the output depends on every entry of the input – unlike Standard Scaler, where the features are independent.
• No state space, deliberately. y = u ÷ ‖u‖ is homogeneous of degree zero – doubling the input leaves the output unchanged – so it is nonlinear and no A/B/C/D is true of it. Model reduction reports the block as unmergeable, which is the honest answer.
• The block is a column map: feed one sample at a time. A matrix input is reported rather than treated as a batch of samples.
• Scale-invariant, which is worth knowing when reading a rig: feeding this block a signal that is one waveform times a constant vector produces a constant output that only flips with the sign of the waveform. A stimulus with independent offsets is what actually exercises it.