1 asptsovlms

Purpose

Sample per sample filtering and coefficient update using the Second Order Volterra Least Mean Squares or one of its variants. The LMS variants currently supported are the sign, sign-sign, and signed regressor algorithms.

Syntax

[w,y,e,xb] = asptsovlms(xn,xb,w,d,mu,L1,L2)
[w,y,e,xb] = asptsovlms(xn,xb,w,d,mu,L1,L2,alg)

Description

asptsovlms() implements the second order Volterra LMS filter (SOVLMS). The SOVLMS 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)$$ (75)

The filter coefficients vector $\vw (n) = [\vw _l(n);\vw _n(n)]$ is updated according to the LMS variety given by the 'alg' input parameter. The memory depth of the linear and nonlinear filter parts are governed independently by the $L1$ and $L2$ parameters passed to init_sovlms(). The input and output parameters of asptsovlms() 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 [1 x 1]
  xb  : buffer of input samples [L1 + sum(1:L2) x 1]
  w   : vector of filter coefficients w(n-1) [L1 + sum(1:L2) x 1]
  d   : desired output d(n) [1 x 1]
  mu  : adaptation constant [2 x 1]
  L1  : memory length of linear part of w
  L2  : memory length of non-linear part of w
  alg : specifies the variety of the lms to use in the 
        update equation. Must be one of the following: 
       'lms'     [default] 
       'slms'  - sign LMS, uses sign(e)
       'srlms' - signed regressor LMS, uses sign(x)
       'sslms' - sign-sign LMS, uses sign(e) and sign(x)
Output parameters ::
  w   : updated filter coefficients w(n)
  y   : filter output y(n)
  e   : error signal; e(n) = d(n) - y(n)
  xb  : updated vector of input samples

Example

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

% SOVLMS 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]=init_sovlms(L1,L2); % Initialize SOVLMS

%% Processing Loop
for (m=1:iter)
   d = dn(m,:) + .001 * rand ;   % additive noise of var = 1e-6 
   % call SOVLMS to calculate the filter output, estimation error
   % and update the coefficients. 
   [w,y,e,xb]= asptsovlms(xn(m),xb,w,d,[.05,.05],L1,L2,'lms');
   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.1. 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 asptsovlms() 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)$.
• Updates the adaptive filter coefficients using the error $e(n)$ and the delay line of input samples $xb(n)$ resulting in $w(n)$.

Remarks

SOVLMS uses the regular LMS algorithm to update both the linear ($\vw _l$) and nonlinear ($\vw _n$) parts of the adaptive filter. Therefore, the convergence properties of the SOVLMS are similar to those of the LMS. For more control on the convergence speed, the step size is a 2-element vector, the first element of which is used to update the linear filter part and the second is used to update the nonlinear part. asptsovlms() also,

• supports both real and complex data and filters. The adaptive filter for the complex SOVLMS 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 SOVLMS filter of linear memory length $L1$ and nonlinear memory length $L2$ are given below. The computations given are those required to process one sample.

MEMORY	$2(L1+sum(1:L2) + 6$
MULTIPLY	$2(L1+sum(1:L2)+L2 + 2$
ADD	$2(L1+sum(1:L2)$
DIVIDE	0

See Also

INIT_ SOVLMS, ASPTSOVNLMS, ASPTLMS.

Reference

[11] and [4] for extensive analysis of the LMS and the steepest-descent search method and [7] for an introduction to the adaptive Volterra filters.