Средняя квадратичная невязка (MSE) измеряет среднее значение квадратов ошибок между желаемым сигналом и входом первичного сигнала к адаптивному фильтру. Уменьшение этой ошибки сходит первичный входной параметр к желаемому сигналу. Определите предсказанное значение MSE и моделируемое значение MSE в каждый момент времени, используя msepred и msesim функций. Сравните эти значения MSE друг с другом и относительно минимальных значений MSE и установившегося MSE. В сложение вычислите сумму квадратов ошибок коэффициента, заданных трассировкой коэффициента ковариации матрице.

Примечание.Если вы используете R2016a или более ранний релиз, замените каждый вызов объекта эквивалентным синтаксисом шага. Для примера, obj(x) становится step(obj,x).

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 функция вычисляет максимальный размер шага адаптивного фильтра. Этот размер шага сохраняет фильтр стабильным на максимально возможной скорости сходимости. Создайте основной входной сигнал, x, путем передачи подписанного случайного сигнала в БИХ. Сигнальное x содержит 50 системы координат по 2000 выборок каждой системы координат. Создайте фильтр LMS с 32 отводами и размером шага 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);

Вычислите максимальный размер шага адаптации и максимальный размер шага в среднеквадратичном смысле с помощью maxstep функция.

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

mumax = 0.0625

mumaxmse = 0.0536

Система идентификации является процессом идентификации коэффициентов неизвестной системы с помощью адаптивного фильтра. Общий обзор процесса показан на Систему идентификации - Использование адаптивного фильтра для идентификации неизвестной системы. Основными компонентами являются:

Цель адаптивного фильтра состоит в том, чтобы минимизировать сигнал ошибки между выходом адаптивного фильтра $\mathit{y}\left(\mathit{k}\right)$ и выходы неизвестной системы (или системы, которая будет идентифицирована) $\mathit{d}\left(\mathit{k}\right)$. Когда сигнал ошибки минимизируется, адаптированный фильтр напоминает неизвестную систему. Коэффициенты обоих фильтров тесно совпадают.

Примечание.Если вы используете R2016a или более ранний релиз, замените каждый вызов объекта эквивалентным синтаксисом шага. Для примера, obj(x) становится step(obj,x).

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')

Чтобы улучшить эффективность LMS-алгоритма, нормализованный вариант (NLMS) использует адаптивный размер шага, основанный на степени сигнала. Когда изменяется степень входного сигнала, алгоритм вычисляет вход степени и настраивает размер шага, чтобы сохранить соответствующее значение. Размер шага изменяется со временем, и в результате нормализованный алгоритм быстрее сходится с меньшим количеством выборок во многих случаях. Для входных сигналов, которые изменяются медленно с течением времени, нормализованный LMS-алгоритм может быть более эффективным подходом LMS.

Для получения примера, использующей подход LMS, смотрите Систему идентификации конечной импульсной характеристики Filter Using LMS-алгоритма.

Примечание.Если вы используете R2016a или более ранний релиз, замените каждый вызов объекта эквивалентным синтаксисом шага. Для примера, obj(x) становится step(obj,x).

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')

Адаптивный фильтр адаптирует свои коэффициенты фильтра так, чтобы они совпадали с коэффициентами неизвестной системы. Цель состоит в том, чтобы минимизировать сигнал ошибки между выходом неизвестной системы и выходом адаптивного фильтра. Когда эти два выхода сходятся и тесно совпадают для одного и того же входа, говорят, что коэффициенты тесно совпадают. Адаптивный фильтр в этом состоянии напоминает неизвестную систему. Этот пример сравнивает скорость, с которой это сходимость происходит для нормализованного алгоритма LMS (NLMS) и LMS-алгоритма без нормализации.

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')

Отмените аддитивный шум n, добавленный в неизвестную систему с помощью адаптивного фильтра LMS. Фильтр LMS адаптирует свои коэффициенты до тех пор, пока его передаточная функция не будет максимально точно соответствовать передаточной функции неизвестной системы. Различие между выходом адаптивного фильтра и выхода неизвестной системы представляет сигнал ошибки e. Минимизация этого сигнала ошибки является целью адаптивного фильтра.

Неизвестная система и фильтр LMS обрабатывают один и тот же входной сигнал, x, и производить выходы d и y, соответственно. Если коэффициенты адаптивного фильтра совпадают с коэффициентами неизвестной системы, ошибка, e, в эффект представляет собой аддитивный шум.

Примечание.Если вы используете R2016a или более ранний релиз, замените каждый вызов объекта эквивалентным синтаксисом шага. Для примера, obj(x) становится step(obj,x).

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)

Когда количество расчета, требуемое для вывода адаптивного фильтра, управляет вашим процессом разработки, вариант sign-data алгоритма LMS (SDLMS) может быть очень хорошим выбором, как показано в этом примере.

В стандартных и нормированных изменениях адаптивного фильтра LMS коэффициенты для адаптирующего фильтра возникают из-за средней квадратной ошибки между желаемым сигналом и выходом сигналом от неизвестной системы. Алгоритм sign-data изменяет среднее вычисление квадратной ошибки с помощью знака входных данных, чтобы изменить коэффициенты фильтра.

Когда ошибка положительная, новые коэффициенты являются предыдущими коэффициентами плюс ошибка, умноженная на размер шага Если ошибка отрицательная, новые коэффициенты снова являются предыдущими коэффициентами минус ошибка, умноженная на, - обратите внимание на изменение знака.

Когда вход равен нулю, новые коэффициенты те же, что и в предыдущем наборе.

В векторной форме LMS-алгоритм со знаком-данными является:

где

с вектором $\mathit{w}$ содержащие веса, примененные к коэффициентам фильтра и вектору $\mathit{x}$ содержит входные данные. Вектор $\mathit{e}$ - ошибка между желаемым сигналом и отфильтрованным сигналом. Цель алгоритма SDLMS состоит в том, чтобы минимизировать эту ошибку. Размер шага представлен $\mu$.

С меньшим $\mu$коррекция к весам фильтра становится меньше для каждой выборки, и ошибка SDLMS падает медленнее. Большее $\mu$ изменяет веса больше для каждого шага, поэтому ошибка падает быстрее, но полученная ошибка не приближается к идеальному решению так близко. Чтобы гарантировать хорошую скорость сходимости и стабильность, выберите $\mu$ в пределах следующих практических границ.

где $\mathit{N}$ - количество выборок в сигнале. Кроме того, задайте $\mu$ как степень двойки для эффективных вычислений.

Примечание: То, как вы устанавливаете начальные условия алгоритма sign-data, глубоко влияет на эффективность процесса адаптации. Поскольку алгоритм по существу квантует входной сигнал, алгоритм может легко стать нестабильным.

Серия больших входных значений в сочетании с процессом квантования может привести к росту ошибки за все границы. Ограничьте склонность алгоритма sign-data к выходу из-под контроля, выбрав небольшой размер шага $\left(\mu \ll 1\right)$ и установка начальных условий для алгоритма ненулевых положительных и отрицательных значений.

В этом примере шумоподавления установите Method свойство dsp.LMSFilter на 'Sign-Data LMS'. Этот пример требует двух наборов входных данных:

Для сигнала используйте синусоиду. Обратите внимание, что signal - вектор-столбец из 1000 элементов.

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

Теперь добавьте коррелированный белый шум к signal. Чтобы убедиться, что шум коррелирует, передайте шум через lowpass конечная импульсная характеристика и затем добавьте отфильтрованный шум к сигналу.

noise = randn(1000,1);
filt = dsp.FIRFilter;
filt.Numerator = fir1(11,0.4);
fnoise = filt(noise);
d = signal + fnoise;

fnoise - коррелированный шум и d теперь является желаемым входом в алгоритм sign-data.

Подготовка dsp.LMSFilter объект для обработки, установите начальные условия весов и mu фильтра (StepSize). Как отмечалось ранее в этом разделе, значения, которые вы задаете для coeffs и mu определите, может ли адаптивный фильтр удалить шум из пути сигнала.

В Система Идентификации of FIR Filter Using LMS Algorithm вы создали фильтр по умолчанию, который устанавливает коэффициенты фильтра в нули. В большинстве случаев этот подход не работает для алгоритма sign-data. Чем ближе вы устанавливаете свои начальные коэффициенты фильтра к ожидаемым значениям, тем больше вероятность, что алгоритм остается хорошо поведенным и сходится к решению фильтра, которое эффективно удаляет шум.

В данном примере начнем с коэффициентов, используемых в шумовом фильтре (filt.Numerator), и немного измените их, чтобы алгоритм должен адаптироваться.

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

С необходимыми входными параметрами для dsp.LMSFilter подготовленный, создайте объект фильтра LMS, запустите адаптацию и просмотрите результаты.

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')

Когда dsp.LMSFilter запускается, он использует гораздо меньше операций умножения, чем любой из стандартных LMS-алгоритмов. Кроме того, выполнение адаптации данных о знаках требует только умножения на перемену бит, когда размер шага является степенью двойки.

Несмотря на то, эффективность алгоритма sign-data, как показано на этом графике, довольно хороша, алгоритм sign-data намного менее стабилен, чем стандартные изменения LMS. В этом примере шумоподавления обработанный сигнал является очень хорошим соответствием входному сигналу, но алгоритм может очень легко расти без привязки, а не достигать хорошей эффективности.

Изменение начальных условий веса (InitialConditions) и mu (StepSize), или даже фильтр lowpass, который вы использовали для создания коррелированного шума, может вызвать отказ шумоподавления.

В стандартных и нормированных изменениях адаптивного фильтра LMS коэффициенты для адаптирующего фильтра возникают из вычисления средней квадратной ошибки между желаемым сигналом и выходом сигналом от неизвестной системы и применения результата к текущим коэффициентам фильтра. Алгоритм LMS (SELMS) заменяет вычисление средней квадратной ошибки, используя знак ошибки, чтобы изменить коэффициенты фильтра.

Когда ошибка положительная, новые коэффициенты являются предыдущими коэффициентами плюс ошибка, умноженная на размер шага $\mu$. Если ошибка отрицательная, новые коэффициенты являются предыдущими коэффициентами минус ошибка, умноженная на $\mu$ - обратите внимание на изменение знака. Когда вход равен нулю, новые коэффициенты те же, что и в предыдущем наборе.

В векторной форме LMS-алгоритм является:

$\mathit{w}\left(\mathit{k}+1\right)=\mathit{w}\left(\mathit{k}\right)+\mu \mathrm{sgn}\left(\mathit{e}\left(\mathit{k}\right)\right)\left(\mathit{x}\left(\mathit{k}\right)\right)$,

где

с вектором $\mathit{w}$ содержащие веса, примененные к коэффициентам фильтра и вектору $\mathit{x}$ содержит входные данные. Вектор $\mathit{e}$ - ошибка между желаемым сигналом и отфильтрованным сигналом. Цель алгоритма SELMS состоит в том, чтобы минимизировать эту ошибку.

С меньшим $\mu$коррекция к весам фильтра становится меньше для каждой выборки, и ошибка SELMS падает более медленно. Большее $\mu$ изменяет веса больше для каждого шага, поэтому ошибка падает быстрее, но полученная ошибка не приближается к идеальному решению так близко. Чтобы гарантировать хорошую скорость сходимости и стабильность, выберите $\mu$ в пределах следующих практических границ.

где $\mathit{N}$ - количество выборок в сигнале. Кроме того, задайте $\mu$ как степень двойки для эффективного расчета.

Примечание: То, как вы устанавливаете начальные условия алгоритма ошибки знака, глубоко влияет на эффективность процесса адаптации. Поскольку алгоритм по существу квантует сигнал ошибки, алгоритм может легко стать нестабильным.

Серия больших значений ошибки в сочетании с процессом квантования может привести к росту ошибки за все границы. Ограничьте склонность алгоритма sign-error стать нестабильным, выбрав небольшой размер шага $\left(\mu \ll 1\right)$ и установка начальных условий для алгоритма ненулевых положительных и отрицательных значений.

В этом примере шумоподавления установите Method свойство dsp.LMSFilter на 'Sign-Error LMS'. Этот пример требует двух наборов входных данных:

Для сигнала используйте синусоиду. Обратите внимание, что signal - вектор-столбец из 1000 элементов.

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

Теперь добавьте коррелированный белый шум к signal. Чтобы убедиться, что шум коррелирует, передайте шум через lowpass конечная импульсная характеристика и затем добавьте отфильтрованный шум к сигналу.

noise = randn(1000,1);
filt = dsp.FIRFilter;
filt.Numerator = fir1(11,0.4);
fnoise = filt(noise);
d = signal + fnoise;

fnoise - коррелированный шум и d теперь является желаемым входом в алгоритм sign-error.

Подготовка dsp.LMSFilter объект для обработки, установите начальные условия весов фильтра (InitialConditions) и mu (StepSize). Как отмечалось ранее в этом разделе, значения, которые вы задаете для coeffs и mu определите, может ли адаптивный фильтр удалить шум из пути сигнала.

В Система Идентификации of FIR Filter Using LMS Algorithm вы создали фильтр по умолчанию, который устанавливает коэффициенты фильтра в нули. В большинстве случаев этот подход не работает для алгоритма ошибки знака. Чем ближе вы устанавливаете свои начальные коэффициенты фильтра к ожидаемым значениям, тем больше вероятность, что алгоритм остается хорошо поведенным и сходится к решению фильтра, которое эффективно удаляет шум.

В данном примере начнем с коэффициентов, используемых в шумовом фильтре (filt.Numerator) и слегка измените их, чтобы алгоритм должен адаптироваться.

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

С необходимыми входными параметрами для dsp.LMSFilter подготовлен, запустите адаптацию и посмотрите результаты.

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')

Когда запускается алгоритм LMS со знаком-ошибкой, он использует гораздо меньше операций умножения, чем любой из стандартных LMS-алгоритмов. Кроме того, выполнение адаптации ошибки знака требует только множителей перемены бит, когда размер шага является степенью двойки.

Несмотря на то, что эффективность алгоритма sign-error, как показано на этом графике, довольно хороша, алгоритм sign-error намного менее стабилен, чем стандартные изменения LMS. В этом примере шумоподавления адаптированный сигнал является очень хорошим соответствием входному сигналу, но алгоритм может очень легко стать нестабильным, а не достигать хорошей эффективности.

Изменение начальных условий веса (InitialConditions) и mu (StepSize), или даже lowpass, который вы использовали для создания коррелированного шума, может вызвать отказ шумоподавления, и алгоритм станет бесполезным.

LMS-алгоритм со знаком (SSLMS) заменяет вычисление средней квадратной ошибки, используя знак входных данных, чтобы изменить коэффициенты фильтра. Когда ошибка положительная, новые коэффициенты являются предыдущими коэффициентами плюс ошибка, умноженная на размер шага $\mu$. Если ошибка отрицательная, новые коэффициенты являются предыдущими коэффициентами минус ошибка, умноженная на $\mu$ - обратите внимание на изменение знака. Когда вход равен нулю, новые коэффициенты те же, что и в предыдущем наборе.

В сущности, алгоритм квантует и ошибку, и вход, применяя к ним оператор знака.

В векторной форме LMS-алгоритм является:

где

Вектор $\mathit{w}$ содержит веса, примененные к коэффициентам фильтра, и вектор $\mathit{x}$ содержит входные данные. Вектор $\mathit{e}$ - ошибка между желаемым сигналом и отфильтрованным сигналом. Цель алгоритма SSLMS состоит в том, чтобы минимизировать эту ошибку.

С меньшим $\mu$коррекция к весам фильтра становится меньше для каждой выборки, и ошибка SSLMS падает более медленно. Большее $\mu$ изменяет веса больше для каждого шага, поэтому ошибка падает быстрее, но полученная ошибка не приближается к идеальному решению так близко. Чтобы гарантировать хорошую скорость сходимости и стабильность, выберите $\mu$ в пределах следующих практических границ.

где $\mathit{N}$ - количество выборок в сигнале. Кроме того, задайте $\mu$ как степень двойки для эффективных расчетов

Примечание:

То, как вы устанавливаете начальные условия алгоритма знака, глубоко влияет на эффективность процесса адаптации. Поскольку алгоритм по существу квантует входной сигнал и сигнал ошибки, алгоритм может легко стать нестабильным.

Серия больших значений ошибки в сочетании с процессом квантования может привести к росту ошибки за все границы. Сдерживайте склонность алгоритма знака-знака стать нестабильным, выбирая небольшой размер шага $\left(\mu \ll 1\right)$ и установка начальных условий для алгоритма ненулевых положительных и отрицательных значений.

В этом примере шумоподавления установите Method свойство dsp.LMSFilter на 'Sign-Sign LMS'. Этот пример требует двух наборов входных данных:

Для сигнала используйте синусоиду. Обратите внимание, что signal - вектор-столбец из 1000 элементов.

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

Теперь добавьте коррелированный белый шум к signal. Чтобы убедиться, что шум коррелирует, передайте шум через lowpass конечная импульсная характеристика, затем добавьте отфильтрованный шум к сигналу.

noise = randn(1000,1);
filt = dsp.FIRFilter;
filt.Numerator = fir1(11,0.4);
fnoise = filt(noise);
d = signal + fnoise;

fnoise - коррелированный шум и d теперь является желаемым входом в алгоритм знака.

Подготовка dsp.LMSFilter объект для обработки, установите начальные условия весов фильтра (InitialConditions) и mu (StepSize). Как отмечалось ранее в этом разделе, значения, которые вы задаете для coeffs и mu определите, может ли адаптивный фильтр удалить шум из пути сигнала. В Система Идентификации of FIR Filter Using LMS Algorithm вы создали фильтр по умолчанию, который устанавливает коэффициенты фильтра в нули. Обычно этот подход не работает для алгоритма знака-знака.

Чем ближе вы устанавливаете свои начальные коэффициенты фильтра к ожидаемым значениям, тем больше вероятность, что алгоритм остается хорошо поведенным и сходится к решению фильтра, которое эффективно удаляет шум. В данном примере вы начинаете с коэффициентов, используемых в шумовом фильтре (filt.Numerator), и немного измените их, чтобы алгоритм должен адаптироваться.

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

С необходимыми входными параметрами для dsp.LMSFilter подготовлен, запустите адаптацию и посмотрите результаты.

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')

Когда dsp.LMSFilter запускается, он использует гораздо меньше операций умножения, чем любой из стандартных LMS-алгоритмов. Кроме того, выполнение адаптации знака-знака требует только множителей перемены бит, когда размер шага является степенью двойки.

Несмотря на то, что эффективность алгоритма знака-знака, как показано на этом графике, довольно хороша, алгоритм знака-знака намного менее стабилен, чем стандартные изменения LMS. В этом примере шумоподавления адаптированный сигнал является очень хорошим соответствием входному сигналу, но алгоритм может очень легко стать нестабильным, а не достигать хорошей эффективности.

Изменение начальных условий веса (InitialConditions) и mu (StepSize), или даже lowpass, который вы использовали для создания коррелированного шума, может вызвать отказ шумоподавления, и алгоритм станет бесполезным.