3 asptouterr

Purpose

Sample per sample filtering and coefficient update using the Output Error recursive adaptive algorithm. The filter transfer function is given by

$$H(z) = \frac{A(z)}{1-B(z)},$$ (53)

Syntax

[u,w,c,y,e,Px,Py]=asptouterr(N,M,u,w,c,x,d,mu,Px,Py)

Description

asptouterr() implements the output error LMS adaptive algorithm used to update recursive adaptive filters. The output error algorithm adjusts the composite filter coefficients vector by minimizing the error signal as shown in Fig. 6.5. asptouterr() takes an input samples $x(n)$, a desired sample $d(n)$, the vector of the adaptive filter coefficients from previous iteration $w(n-1)$, the composite input vector $u(n)$, the step size vector $mu$, and returns the filter output $y(n)$, the error sample $e(n)$ and the updated vector of filter coefficients $w(n)$. The input and output parameters of asptouterr() for a recursive adaptive filter of $N$ numerator coefficients and $M$ denumerator coefficients are summarized below.

Input arguments:
  N  : Number of coefficients of A(z)
  M  : Number of coefficients of B(z)
  u  : composite input vector
  w  : vector of adaptive filter coefficients
  c  : composite gradient vector
  x  : new input sample
  d  : new desired sample
  mu : adaptation constant vector
  Px : variance of x(n)
  Py : variance of y(n)
 Output Parameters:
  u,w,c,Px,Py are the updated input variables
  y  : filter output y(n)
  e  : error signal e(n)

Figure 6.5: Block diagram of the output error algorithm.

Example

Figure 6.6: The adaptive filter response after convergence and the learning curve for the IIR system identification problem using the output error algorithm.

iter = 5000;                    % Number of samples to process
xn   = 2*(rand(iter,1)-0.5)  ;  % Input signal, zero mean random.
dn   = filter([0.6 -.01],[1 -0.4 0.6],xn); % Filter output 
en   = zeros(iter,1);           % error signal

% Initialize OUTERR 
N = 2; M = 2;
[u,w,c,y,d,e,mu,Px,Py]=init_outerr(N,M); 

%% Processing Loop
for (m=1:iter)
   x = xn(m);
   d = dn(m) + 1e-3*rand;   
   % update the filter
   [u,w,c,y,e,Px,Py]=asptouterr(N,M,u,w,c,x,d,mu,Px,Py);   
   % save the last error sample to plot later
   en(m,:) = e;  
end;

wp = filter(w(1:N),[1 ; -w(N+1:N+M)],[1; zeros(19,1)]);

% display the results
subplot(2,2,1);stem(wp); grid;
xlabel('filter response after convergence')
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. 6.6. The left side graph of the figure shows the adaptive filter impulse response after convergence. The right side graph shows the mean square error in dB versus time during the adaptation process, which is usually called the learning curve. 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 output error algorithm is a direct extension of the Wiener filter theory to recursive filters. The filter transfer function is given by

$$w(z) = \frac{A(z)}{1-B(z)}$$ (54)

where

$$A(z) = a_0 + a_1 z^{-1} + ... + a_{N-1} z^{-N+1}$$ (55)

$$B(z) = b_1 z^{-1} + b_2 z^{-2} + ... + b_M z^{-M}$$ (56)

The current implementation of asptouterr() performs the following operations

• Updates the composite input vector $\vu (n)$ using the current and previous samples of $x(n)$ and $y(n)$.
• Filters the composite input vector $\vu (n)$ through the adaptive filter coefficients $\vw (n-1)$ to produce the filter output $y(n)$.
• Calculates the error sample $e(n) = d(n) - y(n)$.
• Calculates the gradient vector $\vc (n)$
• Updates the adaptive filter coefficients using the error $e(n)$ and the gradient vector $\vc (n)$ using the relationship
  

  $$\vw (n) = \vw (n-1) + 2 \; \mu \; e(n) \; \vc (n).$$ (57)

  
  

Remarks

• Being an IIR filter, the adaptive filter $w(n)$ might become unstable during adaptation. This can be avoided by checking that the poles of the filter remain within the unit circle after each call to asptouterr().
• The performance surface searched by the output error algorithm usually has local minima and maxima. Therefore, it is not guaranteed that the filter will converge to a global minimum. This problem is alleviated in the equation error algorithm (see Section 6.2.
• asptouterr() supports both real and complex data and filters.
• asptouterr() updates the composite input vector internally.

Resources

The resources required to implement the OUTERR algorithm for a recursive adaptive filter of $N$ numerator coefficients and $M$ denumerator coefficients in real time is given in the table below. The computations given are those required to process one sample.

MEMORY	$4N + 4M + 5$
MULTIPLY	$3N + 5M + 6$
ADD	$3N + 5M + 2$
DIVIDE	N+M

See Also

INIT_ OUTERR, MODEL_ OUTERR, ASPTEQERR.

Reference

[2] and [10] for introduction to recursive adaptive filters.