3 asptsovrls

Purpose

Sample per sample filtering and coefficients update using the Second Order Volterra Recursive Least Squares (SOVRLS) adaptive algorithm.

Syntax

[w,y,e,R,xb] = asptsovrls(xn,xb,w,d,R,a,L1,L2)

Description

asptsovrls() implements the second order Volterra RLS filter (SOVRLS). The SOVRLS algorithm calculates the filter output $y(n)$ and updates the filter coefficients vector $\vw (n)$. The filter output is the sum of the outputs of the linear filter part $\vw _l(n)$ and the nonlinear part $\vw _n(n)$ as follows.

$$y(n) = \sum \limits_{m_1=0}^{L1-1} w_l(m1) x(n-m_1) + \sum ... ...1-1} \Sigma_{m_2=m_1}^{L2-1} w_n(m1,m2) x(n-m_1) x(n-m_2)$$ (77)

The filter coefficients vector $\vw (n) = [\vw _l(n);\vw _n(n)]$ is updated according to the recursive least squares algorithm equation (4.10). The memory depth of the linear and nonlinear filter parts are governed independently by the $L1$ and $L2$ parameters passed to init_sovrls(). The input and output parameters of asptsovrls() for an FIR adaptive filter of linear memory length $L1$ and nonlinear memory length $L2$ are summarized below.

Input Parameters [Size]:: 
  xn : new input sample
  xb : buffer of input samples [L1 + sum(1:L2) x 1]
  w  : vector of filter coefficients w(n-1), [L x 1]
  d  : desired response d(n), [1 x 1]
  R  : last estimate of the inverse of the weighted 
       auto correlation matrix of x, [L x L]
  a  : forgetting factor, [1 x 1]
  L1 : memory length of linear part of w
  L2 : memory length of non-linear part of w

Output parameters::
  w  : updated filter coefficients w(n)
  y  : filter output y(n)
  e  : error signal, e(n)=d(n)-y(n)
  R  : updated R
  xb : updated buffer of input samples

Example

Figure 8.3: The adaptive filter coefficients after convergence and the learning curve for the FIR system identification problem using the SOVRLS algorithm.

% SOVRLS used in a simple system identification application.
% By the end of this script the adaptive filter w should have 
% the same coefficients as the nonlinear unknown filter h.
iter = 5000;         % Number of samples to process
L1   = 4;
L2   = 4;
% The nonlinear unknown plant transfer function
% y(n) =  x(n) - x(n-1) - .125x(n-2) + .3125x(n-3)
%        +x(n)x(n) -.3x(n)x(n-1) + .2x(n)x(n-2) -.5x(n)x(n-3)
%        +.5x(n-1)x(n-1) -.3x(n-1)x(n-2) -.6x(n-1)x(n-3)
%        -.6x(n-2)x(n-2) +.5x(n-2)x(n-3) -.1x(n-3)x(n-3)
h  =[1;-1;-0;.125;.3125;1;-.3;.2;-.5;.5;-.3;-.6;-.6;.5;-.1];
xn =2*(rand(iter,1)-0.5);      % Input signal, zero mean random.
dn =sovfilt(h,xn,4,4);         % Unknown filter output 
en =zeros(iter,1);             % vector to collect the error
[w,xb,d,y,e,R]=init_sovrls(L1,L2,.001); % Initialize SOVRLS 

%% Processing Loop
for (m=1:iter)
   d = dn(m,:) + .001 * rand ;   % additive noise of var = 1e-6 
   % call SOVRLS to calculate the filter output, estimation error
   % and update the coefficients. 
   [w,y,e,R,xb]=asptsovrls(xn(m),xb,w,d,R,.92,L1,L2);
   en(m,:) = e;                  % save the last error sample 
end;

% display the results
% note that w converges to conj(h) for complex data
subplot(2,2,1);stem([real(w) imag(conj(w))]); grid;
subplot(2,2,2);eb = filter(.1,[1 -.9], en .* conj(en));
plot(10*log10(eb  ));grid

Running the above script will produce the graph shown in Fig. 8.3. The left side graph of the figure shows the adaptive filter coefficients after convergence which are almost identical to the unknown filter h. The right side graph shows the square error in dB versus time during the adaptation process. The lower limit of the error signal power in the learning curve is defined here by the additive white noise added at the filter output (-60 dB).

Algorithm

The current implementation of asptsovrls() performs the following operations

• Constructs the new input samples delay line elements from the previous delay line and new input sample.
• Filters the input delay line $xb(n)$ through the adaptive filter $w(n-1)$ to produce the filter output $y(n)$.
• Calculates the error sample $e(n) = d(n) - y(n)$.
• Recursively updates the gain vector $\vK (n)$.
• Updates the adaptive filter coefficients according to equation (4.10).

Remarks

SOVRLS uses the regular RLS algorithm to update both the linear ($\vw _l$) and nonlinear ($\vw _n$) parts of the adaptive filter. Therefore, the convergence properties of the SOVRLS are similar to those of the RLS. asptsovrls() also,

• supports both real and complex data and filters. The adaptive filter for the complex SOVRLS algorithm converges to the complex conjugate of the optimum solution.
• internally updates the input delay line $xb(n)$ which includes the past linear and nonlinear samples needed for the next iteration. The past samples kept depend on the L1 and L2 parameters.

Resources

The resources required to implement a SOVRLS filter of linear memory length $L1$ and nonlinear memory length $L2$ are given below. The computations given are those required to process one sample. In the table below the symbol $M = (L1+sum(1:L2)$ is used.

MEMORY	$M^2 + 2M + 5$
MULTIPLY	$4M^2 + 3M + L2$
ADD	$3M^2+M$
DIVIDE	M+1

See Also

INIT_ SOVRLS, ASPTRLS.

Reference

[2] and [4] for analysis of the RLS algorithm and its variants and [7] for an introduction to the adaptive Volterra filters..