compute output, error, and weights of lms adaptive filter -凯发k8网页登录

the mean squared error (mse) measures the average of the squares of the errors between the desired signal and the primary signal input to the adaptive filter. reducing this error converges the primary input to the desired signal. determine the predicted value of mse and the simulated value of mse at each time instant using the msepred and msesim functions. compare these mse values with each other and with respect to the minimum mse and steady-state mse values. in addition, compute the sum of the squares of the coefficient errors given by the trace of the coefficient covariance matrix.

num = fir1(31,0.5);
fir = dsp.firfilter('numerator',num);  
iir = dsp.iirfilter('numerator',sqrt(0.75),...
        'denominator',[1 -0.5]);
x = iir(sign(randn(2000,25))); 
n = 0.1*randn(size(x));           
d = fir(x)   n; 

l = 32;
mu = 0.008;
m  = 5;
lms = dsp.lmsfilter('length',l,'stepsize',mu);
[mmse,emse,meanw,mse,tracek] = msepred(lms,x,d,m);
[simmse,meanwsim,wsim,traceksim] = msesim(lms,x,d,m);

nn = m:m:size(x,1);
semilogy(nn,simmse,[0 size(x,1)],[(emse mmse)...
    (emse mmse)],nn,mse,[0 size(x,1)],[mmse mmse])
title('mean squared error performance')
axis([0 size(x,1) 0.001 10])
legend('mse (sim.)','final mse','mse','min. mse')
xlabel('time index')
ylabel('squared error value')

plot(nn,meanwsim(:,12),'b',nn,meanw(:,12),'r',nn,...
meanwsim(:,13:15),'b',nn,meanw(:,13:15),'r')
plottitle ={'average coefficient trajectories for';...
            'w(12), w(13), w(14), and w(15)'}

plottitle = 2x1 cell
    {'average coefficient trajectories for'}
    {'w(12), w(13), w(14), and w(15)'      }

title(plottitle)
legend('simulation','theory')
xlabel('time index')
ylabel('coefficient value')

semilogy(nn,traceksim,nn,tracek,'r')
title('sum-of-squared coefficient errors')
axis([0 size(x,1) 0.0001 1])
legend('simulation','theory')
xlabel('time index')
ylabel('squared error value')

the maxstep function computes the maximum step size of the adaptive filter. this step size keeps the filter stable at the maximum possible speed of convergence. create the primary input signal, x, by passing a signed random signal to an iir filter. signal x contains 50 frames of 2000 samples each frame. create an lms filter with 32 taps and a step size of 0.1.

x = zeros(2000,50);
iirfilter = dsp.iirfilter('numerator',sqrt(0.75),...
    'denominator',[1 -0.5]);
for k = 1:size(x,2)   
  x(:,k) = iirfilter(sign(randn(size(x,1),1))); 
end
mu = 0.1;     
lmsfilter = dsp.lmsfilter('length',32,...
    'stepsize',mu);

compute the maximum adaptation step size and the maximum step size in mean-squared sense using the maxstep function.

[mumax,mumaxmse] = maxstep(lmsfilter,x)

mumax = 0.0625

mumaxmse = 0.0536

system identification is the process of identifying the coefficients of an unknown system using an adaptive filter. the general overview of the process is shown in . the main components involved are:

the objective of the adaptive filter is to minimize the error signal between the output of the adaptive filter y(k) and the output of the unknown system (or the system to be identified) d(k). once the error signal is minimized, the adapted filter resembles the unknown system. the coefficients of both the filters match closely.

filt = dsp.firfilter;
filt.numerator = fircband(12,[0 0.4 0.5 1],[1 1 0 0],[1 0.2],...
{'w' 'c'});

x = 0.1*randn(250,1);
n = 0.01*randn(250,1);
d = filt(x)   n;

mu = 0.8;
lms = dsp.lmsfilter(13,'stepsize',mu)

lms = 
  dsp.lmsfilter with properties:
                   method: 'lms'
                   length: 13
           stepsizesource: 'property'
                 stepsize: 0.8000
            leakagefactor: 1
        initialconditions: 0
           adaptinputport: false
    weightsresetinputport: false
            weightsoutput: 'last'
  show all properties

[y,e,w] = lms(x,d);
plot(1:250, [d,y,e])
title('system identification of an fir filter')
legend('desired','output','error')
xlabel('time index')
ylabel('signal value')

stem([(filt.numerator).' w])
title('system identification by adaptive lms algorithm')
legend('actual filter weights','estimated filter weights',...
       'location','northeast')

mu = 0.2;
lms = dsp.lmsfilter(13,'stepsize',mu);
[~,~,w] = lms(x,d);
stem([(filt.numerator).' w])
title('system identification by adaptive lms algorithm')
legend('actual filter weights','estimated filter weights',...
       'location','northeast')

release(filt);
x = 0.1*randn(1000,1);
n = 0.01*randn(1000,1);
d = filt(x)   n;
[y,e,w] = lms(x,d);
stem([(filt.numerator).' w])
title('system identification by adaptive lms algorithm')
legend('actual filter weights','estimated filter weights',...
       'location','northeast')

release(filt);
n = 0.01*randn(1000,1);
for index = 1:4
  x = 0.1*randn(1000,1);
  d = filt(x)   n;
  [y,e,w] = lms(x,d);
end
stem([(filt.numerator).' w])
title('system identification by adaptive lms algorithm')
legend('actual filter weights','estimated filter weights',...
       'location','northeast')

plot(1:1000, [d,y,e])
title('system identification of an fir filter')
legend('desired','output','error')
xlabel('time index')
ylabel('signal value')

to improve the convergence performance of the lms algorithm, the normalized variant (nlms) uses an adaptive step size based on the signal power. as the input signal power changes, the algorithm calculates the input power and adjusts the step size to maintain an appropriate value. the step size changes with time, and as a result, the normalized algorithm converges faster with fewer samples in many cases. for input signals that change slowly over time, the normalized lms algorithm can be a more efficient lms approach.

for an example using the lms approach, see .

filt = dsp.firfilter;
filt.numerator = fircband(12,[0 0.4 0.5 1],[1 1 0 0],[1 0.2],...
{'w' 'c'});

x = 0.1*randn(1000,1);
n = 0.001*randn(1000,1);
d = filt(x)   n;

mu = 0.2;
lms = dsp.lmsfilter(13,'stepsize',mu,'method',...
   'normalized lms');

[y,e,w] = lms(x,d);

plot(1:1000, [d,y,e])
title('system identification by normalized lms algorithm')
legend('desired','output','error')
xlabel('time index')
ylabel('signal value')

stem([(filt.numerator).' w])
title('system identification by normalized lms algorithm')
legend('actual filter weights','estimated filter weights',...
       'location','northeast')

an adaptive filter adapts its filter coefficients to match the coefficients of an unknown system. the objective is to minimize the error signal between the output of the unknown system and the output of the adaptive filter. when these two outputs converge and match closely for the same input, the coefficients are said to match closely. the adaptive filter at this state resembles the unknown system. this example compares the rate at which this convergence happens for the normalized lms (nlms) algorithm and the lms algorithm with no normalization.

filt = dsp.firfilter;
filt.numerator = fircband(12,[0 0.4 0.5 1],[1 1 0 0],[1 0.2],...
{'w' 'c'});
x = 0.1*randn(1000,1);
n = 0.001*randn(1000,1);
d = filt(x)   n;

mu = 0.2;
lms_nonnormalized = dsp.lmsfilter(13,'stepsize',mu,...
    'method','lms');
lms_normalized = dsp.lmsfilter(13,'stepsize',mu,...
    'method','normalized lms');

[~,e1,~] = lms_normalized(x,d);
[~,e2,~] = lms_nonnormalized(x,d);

plot([e1,e2]);
title('comparing the lms and nlms conversion performance');
legend('nlms derived filter weights', ...
       'lms derived filter weights','location', 'northeast');
xlabel('time index')
ylabel('signal value')

cancel additive noise, n, added to an unknown system using an lms adaptive filter. the lms filter adapts its coefficients until its transfer function matches the transfer function of the unknown system as closely as possible. the difference between the output of the adaptive filter and the output of the unknown system represents the error signal, e. minimizing this error signal is the objective of the adaptive filter.

the unknown system and the lms filter process the same input signal, x, and produce outputs d and y, respectively. if the coefficients of the adaptive filter match the coefficients of the unknown system, the error, e, in effect represents the additive noise.

framesize = 100;
niter = 10;
lmsfilt2 = dsp.lmsfilter('length',11,'method','normalized lms', ...
    'stepsize',0.05);
firfilt2 = dsp.firfilter('numerator', fir1(10,[.5, .75]));
sinewave = dsp.sinewave('frequency',0.01, ...
    'samplerate',1,'samplesperframe',framesize);
scope = timescope('timeunits','seconds',...
    'ylimits',[-3 3],'bufferlength',2*framesize*niter, ...
    'showlegend',true,'channelnames', ...
    {'noisy signal', 'error signal'});

for k = 1:niter
    x = randn(framesize,1);
    d = firfilt2(x)   sinewave();
    [y,e,w] = lmsfilt2(x,d);
    scope([d,e])
end
release(scope)

when the amount of computation required to derive an adaptive filter drives your development process, the sign-data variant of the lms (sdlms) algorithm might be a very good choice, as demonstrated in this example.

in the standard and normalized variations of the lms adaptive filter, coefficients for the adapting filter arise from the mean square error between the desired signal and the output signal from the unknown system. the sign-data algorithm changes the mean square error calculation by using the sign of the input data to change the filter coefficients.

when the error is positive, the new coefficients are the previous coefficients plus the error multiplied by the step size µ. if the error is negative, the new coefficients are again the previous coefficients minus the error multiplied by µ — note the sign change.

when the input is zero, the new coefficients are the same as the previous set.

in vector form, the sign-data lms algorithm is:

where

with vector w containing the weights applied to the filter coefficients and vector x containing the input data. the vector e is the error between the desired signal and the filtered signal. the objective of the sdlms algorithm is to minimize this error. step size is represented by μ.

with a smaller μ, the correction to the filter weights gets smaller for each sample, and the sdlms error falls more slowly. a larger μ changes the weights more for each step, so the error falls more rapidly, but the resulting error does not approach the ideal solution as closely. to ensure a good convergence rate and stability, select μ within the following practical bounds.

where n is the number of samples in the signal. also, define μ as a power of two for efficient computing.

note: how you set the initial conditions of the sign-data algorithm profoundly influences the effectiveness of the adaptation process. because the algorithm essentially quantizes the input signal, the algorithm can become unstable easily.

a series of large input values, coupled with the quantization process might result in the error growing beyond all bounds. restrain the tendency of the sign-data algorithm to get out of control by choosing a small step size (μ≪1) and setting the initial conditions for the algorithm to nonzero positive and negative values.

in this noise cancellation example, set the method property of dsp.lmsfilter to 'sign-data lms'. this example requires two input data sets:

for the signal, use a sine wave. note that signal is a column vector of 1000 elements.

signal = sin(2*pi*0.055*(0:1000-1)');

now, add correlated white noise to signal. to ensure that the noise is correlated, pass the noise through a lowpass fir filter and then add the filtered noise to the signal.

noise = randn(1000,1);
filt = dsp.firfilter;
filt.numerator = fir1(11,0.4);
fnoise = filt(noise);
d = signal   fnoise;

fnoise is the correlated noise and d is now the desired input to the sign-data algorithm.

to prepare the dsp.lmsfilter object for processing, set the initial conditions of the filter weights and mu (stepsize). as noted earlier in this section, the values you set for coeffs and mu determine whether the adaptive filter can remove the noise from the signal path.

in system identification of fir filter using lms algorithm, you constructed a default filter that sets the filter coefficients to zeros. in most cases that approach does not work for the sign-data algorithm. the closer you set your initial filter coefficients to the expected values, the more likely it is that the algorithm remains well behaved and converges to a filter solution that removes the noise effectively.

for this example, start with the coefficients used in the noise filter (filt.numerator), and modify them slightly so the algorithm has to adapt.

coeffs = (filt.numerator).'-0.01; % set the filter initial conditions.
mu = 0.05; % set the step size for algorithm updating.

with the required input arguments for dsp.lmsfilter prepared, construct the lms filter object, run the adaptation, and view the results.

lms = dsp.lmsfilter(12,'method','sign-data lms',...
   'stepsize',mu,'initialconditions',coeffs);
[~,e] = lms(noise,d);
l = 200;
plot(0:l-1,signal(1:l),0:l-1,e(1:l));
title('noise cancellation by the sign-data algorithm');
legend('actual signal','result of noise cancellation',...
       'location','northeast');
xlabel('time index')
ylabel('signal values')

when dsp.lmsfilter runs, it uses far fewer multiplication operations than either of the standard lms algorithms. also, performing the sign-data adaptation requires only multiplication by bit shifting when the step size is a power of two.

although the performance of the sign-data algorithm as shown in this plot is quite good, the sign-data algorithm is much less stable than the standard lms variations. in this noise cancellation example, the processed signal is a very good match to the input signal, but the algorithm could very easily grow without bound rather than achieve good performance.

changing the weight initial conditions (initialconditions) and mu (stepsize), or even the lowpass filter you used to create the correlated noise, can cause noise cancellation to fail.

in the standard and normalized variations of the lms adaptive filter, the coefficients for the adapting filter arise from calculating the mean square error between the desired signal and the output signal from the unknown system, and applying the result to the current filter coefficients. the sign-error lms (selms) algorithm replaces the mean square error calculation by using the sign of the error to modify the filter coefficients.

when the error is positive, the new coefficients are the previous coefficients plus the error multiplied by the step size μ. if the error is negative, the new coefficients are the previous coefficients minus the error multiplied by μ — note the sign change. when the input is zero, the new coefficients are the same as the previous set.

in vector form, the sign-error lms algorithm is:

w(k 1)=w(k) μsgn(e(k))(x(k)),

where

with vector w containing the weights applied to the filter coefficients and vector x containing the input data. the vector e is the error between the desired signal and the filtered signal. the objective of the selms algorithm is to minimize this error.

with a smaller μ, the correction to the filter weights gets smaller for each sample and the selms error falls more slowly. a larger μ changes the weights more for each step so the error falls more rapidly, but the resulting error does not approach the ideal solution as closely. to ensure a good convergence rate and stability, select μ within the following practical bounds.

where n is the number of samples in the signal. also, define μ as a power of two for efficient computation.

note: how you set the initial conditions of the sign-error algorithm profoundly influences the effectiveness of the adaptation process. because the algorithm essentially quantizes the error signal, the algorithm can become unstable easily.

a series of large error values, coupled with the quantization process might result in the error growing beyond all bounds. restrain the tendency of the sign-error algorithm to become unstable by choosing a small step size (μ≪1) and setting the initial conditions for the algorithm to nonzero positive and negative values.

in this noise cancellation example, set the method property of dsp.lmsfilter to 'sign-error lms'. this example requires two input data sets:

for the signal, use a sine wave. note that signal is a column vector of 1000 elements.

signal = sin(2*pi*0.055*(0:1000-1)');

now, add correlated white noise to signal. to ensure that the noise is correlated, pass the noise through a lowpass fir filter and then add the filtered noise to the signal.

noise = randn(1000,1);
filt = dsp.firfilter;
filt.numerator = fir1(11,0.4);
fnoise = filt(noise);
d = signal   fnoise;

fnoise is the correlated noise and d is now the desired input to the sign-error algorithm.

to prepare the dsp.lmsfilter object for processing, set the initial conditions of the filter weights (initialconditions) and mu (stepsize). as noted earlier in this section, the values you set for coeffs and mu determine whether the adaptive filter can remove the noise from the signal path.

in system identification of fir filter using lms algorithm, you constructed a default filter that sets the filter coefficients to zeros. in most cases that approach does not work for the sign-error algorithm. the closer you set your initial filter coefficients to the expected values, the more likely it is that the algorithm remains well behaved and converges to a filter solution that removes the noise effectively.

for this example, start with the coefficients used in the noise filter (filt.numerator) and modify them slightly so the algorithm has to adapt.

coeffs = (filt.numerator).'-0.01; % set the filter initial conditions.
mu = 0.05; % set the step size for algorithm updating.

with the required input arguments for dsp.lmsfilter prepared, run the adaptation and view the results.

lms = dsp.lmsfilter(12,'method','sign-error lms',...
   'stepsize',mu,'initialconditions',coeffs);
[~,e] = lms(noise,d);
l = 200;
plot(0:199,signal(1:200),0:199,e(1:200));
title('noise cancellation performance by the sign-error lms algorithm');
legend('actual signal','error after noise reduction',...
       'location','northeast')
xlabel('time index')
ylabel('signal value')

when the sign-error lms algorithm runs, it uses far fewer multiplication operations than either of the standard lms algorithms. also, performing the sign-error adaptation requires only bit shifting multiples when the step size is a power of two.

although the performance of the sign-error algorithm as shown in this plot is quite good, the sign-error algorithm is much less stable than the standard lms variations. in this noise cancellation example, the adapted signal is a very good match to the input signal, but the algorithm could very easily become unstable rather than achieve good performance.

changing the weight initial conditions (initialconditions) and mu (stepsize), or even the lowpass filter you used to create the correlated noise, can cause noise cancellation to fail and the algorithm to become useless.

the sign-sign lms algorithm (sslms) replaces the mean square error calculation by using the sign of the input data to change the filter coefficients. when the error is positive, the new coefficients are the previous coefficients plus the error multiplied by the step size μ. if the error is negative, the new coefficients are the previous coefficients minus the error multiplied by μ — note the sign change. when the input is zero, the new coefficients are the same as the previous set.

in essence, the algorithm quantizes both the error and the input by applying the sign operator to them.

in vector form, the sign-sign lms algorithm is:

where

vector w contains the weights applied to the filter coefficients and vector x contains the input data. the vector e is the error between the desired signal and the filtered signal. the objective of the sslms algorithm is to minimize this error.

with a smaller μ, the correction to the filter weights gets smaller for each sample and the sslms error falls more slowly. a larger μ changes the weights more for each step, so the error falls more rapidly, but the resulting error does not approach the ideal solution as closely. to ensure a good convergence rate and stability, select μ within the following practical bounds.

where n is the number of samples in the signal. also, define μ as a power of two for efficient computation

note:

how you set the initial conditions of the sign-sign algorithm profoundly influences the effectiveness of the adaptation process. because the algorithm essentially quantizes the input signal and the error signal, the algorithm can become unstable easily.

a series of large error values, coupled with the quantization process might result in the error growing beyond all bounds. restrain the tendency of the sign-sign algorithm to become unstable by choosing a small step size (μ≪1) and setting the initial conditions for the algorithm to nonzero positive and negative values.

in this noise cancellation example, set the method property of dsp.lmsfilter to 'sign-sign lms'. this example requires two input data sets:

for the signal, use a sine wave. note that signal is a column vector of 1000 elements.

signal = sin(2*pi*0.055*(0:1000-1)');

now, add correlated white noise to signal. to ensure that the noise is correlated, pass the noise through a lowpass fir filter, then add the filtered noise to the signal.

noise = randn(1000,1);
filt = dsp.firfilter;
filt.numerator = fir1(11,0.4);
fnoise = filt(noise);
d = signal   fnoise;

fnoise is the correlated noise and d is now the desired input to the sign-sign algorithm.

to prepare the dsp.lmsfilter object for processing, set the initial conditions of the filter weights (initialconditions) and mu (stepsize). as noted earlier in this section, the values you set for coeffs and mu determine whether the adaptive filter can remove the noise from the signal path. in system identification of fir filter using lms algorithm, you constructed a default filter that sets the filter coefficients to zeros. usually that approach does not work for the sign-sign algorithm.

the closer you set your initial filter coefficients to the expected values, the more likely it is that the algorithm remains well behaved and converges to a filter solution that removes the noise effectively. for this example, you start with the coefficients used in the noise filter (filt.numerator), and modify them slightly so the algorithm has to adapt.

coeffs = (filt.numerator).' -0.01; % set the filter initial conditions.
mu = 0.05;

with the required input arguments for dsp.lmsfilter prepared, run the adaptation and view the results.

lms = dsp.lmsfilter(12,'method','sign-sign lms',...
   'stepsize',mu,'initialconditions',coeffs);
[~,e] = lms(noise,d);
l = 200;
plot(0:199,signal(1:200),0:199,e(1:200));
title('noise cancellation performance by the sign-sign lms algorithm');
legend('actual signal','error after noise reduction',...
       'location','northeast')
xlabel('time index')
ylabel('signal value')

when dsp.lmsfilter runs, it uses far fewer multiplication operations than either of the standard lms algorithms. also, performing the sign-sign adaptation requires only bit shifting multiples when the step size is a power of two.

although the performance of the sign-sign algorithm as shown in this plot is quite good, the sign-sign algorithm is much less stable than the standard lms variations. in this noise cancellation example, the adapted signal is a very good match to the input signal, but the algorithm could very easily become unstable rather than achieve good performance.

changing the weight initial conditions (initialconditions) and mu (stepsize), or even the lowpass filter you used to create the correlated noise, can cause noise cancellation to fail and the algorithm to become useless.