2 asptsovnlms

Purpose

Sample per sample filtering and coefficients update using the Second Order Volterra Normalized Least Mean Squares Adaptive Filter algorithm.

Syntax

[w,y,e,xb,p] = asptsovnlms(xn,xb,w,d,mu,L1,L2,p)
[w,y,e,xb,p] = asptsovnlms(xn,xb,w,d,mu,L1,L2,p,b)

Description

asptsovnlms() implements the second order Volterra NLMS filter (SOVNLMS). The SOVNLMS 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)$$ (76)

The filter coefficients vector $\vw (n) = [\vw _l(n);\vw _n(n)]$ is updated according to the Normalized LMS algorithm. The memory depth of the linear and nonlinear filter parts are governed independently by the $L1$ and $L2$ parameters passed to init_sovnlms(). The input and output parameters of asptsovnlms() 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
  p  : input signal power [2 x 1]
  b  : low pass filter pole used to estimate p.

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
  p  : updated input signal power.

Example

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

% SOVNLMS 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,p]=init_sovnlms(L1,L2); % Initialize SOVNLMS

%% Processing Loop
for (m=1:iter)
   d = dn(m,:) + .001 * rand ;   % additive noise of var = 1e-6 
   % call SOVNLMS to calculate the filter output, estimation error
   % and update the coefficients. 
   [w,y,e,xb,p]= asptsovnlms(xn(m),xb,w,d,[.05,.05],L1,L2,p,.98);
   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.2. 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 asptsovnlms() 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)$.
• Estimates the power of the input signal and its cross-products to be used in normalizing the update of the linear and nonlinear filter parts, respectively.
• Updates the adaptive filter coefficients using the error $e(n)$ and the delay line of input samples $xb(n)$ resulting in $w(n)$.

Remarks

SOVNLMS uses the regular NLMS algorithm to update both the linear ($\vw _l$) and nonlinear ($\vw _n$) parts of the adaptive filter. Therefore, the convergence properties of the SOVNLMS are similar to those of the NLMS. 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. A vector of two elements is also used for the power normalization. asptsovnlms() also,

• supports both real and complex data and filters. The adaptive filter for the complex SOVNLMS 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 SOVNLMS 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) + 9$
MULTIPLY	$2(L1+sum(1:L2)+2L2 + 5$
ADD	$2(L1+sum(1:L2)+L2+1$
DIVIDE	2

See Also

INIT_ SOVNLMS, ASPTSOVLMS, ASPTNLMS.

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.