System Identification Using RLS Adaptive Filtering

This example shows how to use a recursive least-squares (RLS) filter to identify an unknown system modeled with a lowpass FIR filter. Use the dynamic filter visualizer to compare the frequency response of the unknown and estimated systems. This example allows you to dynamically tune key simulation parameters using a user interface (UI). The example also shows you how to use MATLAB Coder™ to generate code for the algorithm and accelerate the speed of its execution.

Required MathWorks™ products:

• DSP System Toolbox™

Optional MathWorks products:

• MATLAB Coder for generating C code from the MATLAB simulation

• Simulink® for executing the Simulink version of the example

Introduction

Adaptive system identification is one of the main applications of adaptive filtering. This example showcases system identification using an RLS filter. The example's workflow is depicted below:

The unknown system is modeled by a lowpass FIR filter. The same input is fed to the FIR and RLS filters. The desired signal is the output of the unidentified system. The estimated weights of the RLS filter therefore converges to the coefficients of the FIR filter. The coefficients of the RLS filter and FIR filter are used by the dynamic filter visualizer to visualize the desired and estimated frequency response. The learning curve of the RLS filter (the plot of the mean square error (MSE) of the filter versus time) is also visualized.

Tunable FIR Filter

The lowpass FIR filter used in this example is modeled using a dsp.VariableBandwidthFIRFilter System object. This object allows you to tune the filter's cutoff frequency while preserving the FIR structure. Tuning is achieved by multiplying each filter coefficient by a factor proportional to the current and desired cutoff frequencies.

MATLAB Simulation

HelperRLSFilterSystemIdentificationSim is the function containing the algorithm's implementation. It instantiates, initializes and steps through the objects forming the algorithm.

The function RLSFilterSystemIDExampleApp wraps around HelperRLSFilterSystemIdentificationSim and iteratively calls it, providing continuous adapting to the unidentified FIR system. Using dsp.DynamicFilterVisualizer the application also plots the following:

1. The desired versus estimated frequency transfer functions.

2. The learning curve of the RLS filter.

Plotting occurs when the 'plotResults' input to the function is 'true'.

Execute RLSFilterSystemIDExampleApp to run the simulation and plot the results on scopes. Note that the simulation runs for as long as the user does not explicitly stop it.

The plots below are the output of running the above simulation for 100 time-steps:

The fast convergence of the RLS filter towards the FIR filter can be seen through the above plots.

RLSFilterSystemIDExampleApp launches a User Interface (UI) designed to interact with the simulation. The UI allows you to tune parameters and the results are reflected in the simulation instantly. For example, moving the slider for the 'Cutoff Frequency' to the right while the simulation is running, increases the FIR filter's cutoff frequency. Similarly, moving the slider for the 'RLS Forgetting Factor' tunes the forgetting factor of the RLS filter. The plots reflects your changes as you tune these parameters. For more information on the UI, please refer to HelperCreateParamTuningUI.

There are also two buttons on the UI - the 'Reset' button resets the states of the RLS and FIR filters to their initial values, and 'Stop simulation' ends the simulation. If you tune the RLS filter's forgetting factor to a value that is too low, you will notice that the RLS filter fails to converge to the desired solution, as expected. You can restore convergence by first increasing the forgetting factor to an acceptable value, and then clicking the 'Reset' button. Use the UI to control either the simulation or, optionally, a MEX-file (or standalone executable) generated from the simulation code as detailed below. If you have a MIDI controller, it is possible to synchronize it with the UI. You can do this by choosing a MIDI control in the dialog that is opened when you right-click on the sliders or buttons and select "Synchronize" from the context menu. The chosen MIDI control then works in accordance with the slider/button so that operating one control is tracked by the other.

Generating the MEX-File

MATLAB Coder can be used to generate C code for the function HelperRLSFilterSystemIdentificationSim as well. In order to generate a MEX-file for your platform, execute the following:

currDir = pwd;  % Store the current directory address
addpath(pwd)
mexDir   = [tempdir 'RLSFilterSystemIdentificationExampleMEXDir']; % Name of                                          
% temporary directory
if ~exist(mexDir,'dir')
    mkdir(mexDir);       % Create temporary directory
end
cd(mexDir);          % Change directory

ParamStruct = HelperRLSCodeGeneration();

Code generation successful: To view the report, open('codegen/mex/HelperRLSFilterSystemIdentificationSim/html/report.mldatx')

By calling the wrapper function RLSFilterSystemIDExampleApp with 'true' as an argument, the generated MEX-file HelperRLSFilterSystemIdentificationSimMEX can be used instead of HelperRLSFilterSystemIdentificationSim for the simulation. In this scenario, the UI is still running inside the MATLAB environment, but the main processing algorithm is being performed by a MEX-file. Performance is improved in this mode without compromising the ability to tune parameters.

Click here to call RLSFilterSystemIDExampleApp with 'true' as argument to use the MEX-file for simulation. Again, the simulation runs till the user explicitly stops it from the UI.

Simulation Versus MEX Speed Comparison

Creating MEX-Files often helps achieve faster run-times for simulations. In order to measure the performance improvement, let's first time the execution of the algorithm in MATLAB without any plotting:

clear HelperRLSFilterSystemIdentificationSim
disp('Running the MATLAB code...')

Running the MATLAB code...

tic
nTimeSteps = 100;
for ind = 1:nTimeSteps
     HelperRLSFilterSystemIdentificationSim(ParamStruct);
end
tMATLAB = toc;

Now let's time the run of the corresponding MEX-file and display the results:

clear HelperRLSFilterSystemIdentificationSim
disp('Running the MEX-File...')

Running the MEX-File...

tic
for ind = 1:nTimeSteps
    HelperRLSFilterSystemIdentificationSimMEX(ParamStruct);
end
tMEX = toc;

disp('RESULTS:')

RESULTS:

disp(['Time taken to run the MATLAB System object: ', num2str(tMATLAB),...
     ' seconds']);

Time taken to run the MATLAB System object: 1.5024 seconds

disp(['Time taken to run the MEX-File: ', num2str(tMEX), ' seconds']);

Time taken to run the MEX-File: 0.28727 seconds

disp(['Speed-up by a factor of ', num2str(tMATLAB/tMEX),...
    ' is achieved by creating the MEX-File']);

Speed-up by a factor of 5.2301 is achieved by creating the MEX-File

Clean up Generated Files

The temporary directory previously created can be deleted through:

cd(currDir);
clear HelperRLSFilterSystemIdentificationSimMEX;
rmdir(mexDir, 's');

Simulink Version

rlsfiltersystemidentification is a Simulink model that implements the RLS System identification example highlighted in the previous sections.

In this model, the unknown system is a lowpass FIR filter is modeled using the Variable Bandwidth FIR Filter block. Inside the System Identification subsystem, the Variable Bandwidth FIR Filter block takes in the input signal and provides the filtered signal at the output. The input signal along with this desired output signal are fed to the RLS Filter block which estimates the weights of the filter.

The coefficients of the lowpass filter are fed to the Filter Visualizer to visualize the magnitude response of the filter.

Double-click the System Identification subsystem to launch the mask designed to interact with the Simulink model. You can tune the cutoff frequency of the FIR filter and the forgetting factor of the RLS filter.

The model generates code when it is simulated. Therefore, it must be executed from a folder with write permissions.