5 asptsovvsslms

Purpose

Sample per sample filtering and coefficients update using the Second Order Volterra Variable Step Size Least Mean Squares Adaptive filter algorithm.

Syntax

[w,g,mu,y,e,xb] = asptsovvsslms(xn,xb,w,g,d,mu,L1,L2,roh)
[w,g,mu,y,e,xb] = asptsovvsslms(xn,xb,w,g,d,mu,L1,L2,roh,
ssa,mu_min,mu_max)

Description

asptsovvsslms() implements the second order Volterra variable step size LMS adaptive filter (SOVVSSLMS). The SOVVSSLMS algorithm calculates the filter output $y(n)$, updates the filter coefficients vector $\vw (n)$, and updates the algorithm step size $\mu(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)$$ (79)

The filter coefficients vector $\vw (n) = [\vw _l(n);\vw _n(n)]$ is updated according to the VSSLMS algorithm. The memory depth of the linear and nonlinear filter parts are governed independently by the $L1$ and $L2$ parameters passed to init_sovvsslms(). The input and output parameters of asptsovvsslms() 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 [L1 + sum(1:L2) x 1]
  g   : gradient vector [L1 + sum(1:L2) x 1]
  d   : desired output [1 x 1]
  mu  : step size vector [L1 + sum(1:L2) x 1]
  L1  : memory length of linear part of w
  L2  : memory length of non-linear part of w
  roh    : mu step size [1 x 1]
  ssa    : if 1, the sign-sign algorithm is used to update mu.
  mu_min : lower bound for mu [1 x 1]
  mu_max : higher bound for mu [1 x 1]

Output parameters ::

  w   : updated filter coefficients w(n)
  g   : updated gradient vector g(n)
  mu  : updated vector of step sizes mu(n)
  y   : filter output y(n)
  e   : error signal; e(n) = d(n) - y(n)
  xb  : updated vector of input samples

Example

Figure 8.5: The adaptive filter coefficients after convergence, the evolution of the step size, and the learning curve for the FIR system identification problem using the SOVVSSLMS algorithm.

% SOVVSSLMS 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
mu0 =0.05*ones(L1+sum(1:L2),1); % initial step size
muv =zeros(iter,1);             % Evolution of mu(1)
% Initialize the SOVVSSLMS algorithm
[w,xb,d,y,e,g,mu] = init_sovvsslms(L1,L2,[],[],[],mu0);;

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

% display the results
subplot(3,3,1);stem(w); grid;
eb = filter(0.1,[1 -0.9], en .* conj(en));
subplot(3,3,2);plot(10*log10(eb ) );grid
subplot(3,3,3);plot(muv); grid;

Running the above script will produce the graph shown in Fig. 8.5. The left side graph of the figure shows the adaptive filter coefficients after convergence. The middle graph shows the square error in dB versus time during the adaptation process. The right side graph shows the evolution of the first element of the step size vector during the adaptation process.

Algorithm

The current implementation of asptsovvsslms() 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 step size vector and limits its elements if necessary.
• Updates the adaptive filter coefficients using the error $e(n)$ and the delay line of input samples $xb(n)$ resulting in $w(n)$.

Remarks

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

• supports both real and complex data and filters. The adaptive filter for the complex SOVVSSLMS algorithm converges to the complex conjugate of the optimum solution.
• updates the input delay line $xb(n)$ internally 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 SOVVSSLMS filter of linear memory length $L1$ and nonlinear memory length $L2$ are given below. The computations given are those required to process one real-value input sample.

MEMORY	$4(L1+sum(1:L2) + 8$
MULTIPLY	$5(L1+sum(1:L2)+L2$
ADD	$3(L1+sum(1:L2)$
DIVIDE	0

See Also

INIT_ SOVVSSLMS, ASPTVSSLMS, ASPTMVSSLMS, ASPTVFFRLS.

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.