LMS Filter — System Identification/Adaptive Filters

LMS Filter

System Identification / Adaptive Filters

An adaptive FIR filter that tunes its own taps to make its output match a desired signal. Each step it forms the tap line x = [u[k], u[k−1], … u[k−L+1]], produces y = w′·x, measures e = d − y, and steps the weights along the instantaneous gradient: w[k+1] = w[k] + 2μ·e·x. Normalized LMS divides that step by the tap power, which makes the convergence rate independent of how loud the input is.

Ports

• u – the filter input, scalar. It is what fills the tap line, so the whole of x is this one signal delayed.
• d – the desired (reference) signal, scalar. What the filter is being asked to reproduce from u.
• y – the filter output w′·x, scalar, computed from the weights as they stood BEFORE this sample's update.
• e – the error d − y, scalar. This is the signal the filter is minimising, and in an interference-cancelling wiring it is the useful output rather than y.
• w – the weight vector, [L,1] from Filter Length, carrying the weights AFTER this sample's update. Published after rather than before deliberately: a dropped or mis-scaled step then shows on the first samples instead of hiding inside y until the filter converges somewhere different.

Parameters

• Filter Length – the number of taps L, a positive whole number. It sets the tap line depth, the width of the w port, and how far back in u the filter can reach.
• Step Size – μ, the adaptation gain, entering the update as 2μ. Larger converges faster and sits noisier at the solution; too large diverges. For plain LMS stability needs roughly μ < 1/(L·E[u²]); for NLMS the normalizer removes the signal-power term and 0 < μ < 1 is the usable band.
• Initial Weights – the seed for w. A scalar is broadcast to all L taps; a vector of exactly L entries is taken in order. Anything else is reported and stops the run.
• Adaptation Method – which update law runs:
  • LMS – w += 2μ·e·x. Multiply-accumulate only, no division.
  • Normalized LMS (NLMS) – w += 2μ·e·x ÷ max(x′x, Epsilon). The step is scaled by the current tap power, so a loud stretch of input does not overshoot and a quiet one does not stall.
• NLMS Epsilon – the FLOOR under the normalizer, not an added term: the divisor is max(x′x, Epsilon), so a silent tap line cannot divide by zero. Unused by the LMS method. It floors rather than regularizes so that on any tap line carrying real signal the value changes nothing at all.
• 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. L, μ, the method and Epsilon are fixed at export time, so every array bound is a compile-time constant and the weights are seeded from Initial Weights in each target – read from the configuration, never from the running filter, whose weights have already moved by the time an export is taken.

The three HDL targets depend on the method, which is the one thing worth knowing before choosing one:

• LMS exports as genuinely synthesizable Q16.16 fixed point. The update is multiply-accumulate with no division, so it stays in the same fixed-point datapath the signal ports already use.
• Normalized LMS exports as simulation-only: the normalizer is a data-dependent divide, so the recursion is carried in double arithmetic and quantized only on the way out to the fixed-point ports.

μ, Epsilon and the initial weights are baked into the body at export time rather than exposed as tunable parameters – they are structural here, since changing L changes every array bound in the emitted core.

Simulink bridge

Neither direction. The System Identification Toolbox is not installed on this machine, so a bridge could not be verified against the real block even if it were written; the bridge reports this block with that reason rather than silently dropping it.

Notes

• Stateful and discrete only. The state is the weight vector and the tap line. Both start from their seeds, and unlike the recursive identification blocks there is no warm-up: a tap line of zeros is exactly the definition of u[k] = 0 for k < 0, so the filter is correct from the first sample.
• No state space, deliberately. The output is a product of two things that both move – the weights and the signal – so the map is nonlinear and no A/B/C/D is true of it. Model reduction reports the block as unmergeable, which is the honest answer.
• What the filter converges to is set by the excitation. If u does not stir the part of the response d needs, no step size identifies it – pair this with a rich excitation such as a PRBS or multisine source.