È numericamente più stabile implementare il filtraggio come moltiplicazione o convoluzione?

Sto scrivendo un programma per filtrare un segnale di 20.000 campioni con un filtro Butterworth di quinto ordine offline. Ho accesso a un'implementazione FFT. Sembra che ci siano due alternative per l'implementazione del filtro:

• coinvolgendo il segnale con la risposta all'impulso nel dominio del tempo, o
• moltiplicando il segnale con la risposta all'impulso nel dominio della frequenza e trasformando inversa il risultato

Questi metodi sarebbero identici nel caso FT teorico. Farlo nella vita reale con il DFT, tuttavia, suppongo che le cose siano diverse. Uno dei metodi è numericamente più stabile? Ci sono altri problemi di cui dovrei essere a conoscenza? Il numero di calcoli non è importante.

Con convoluzione, non si verificheranno problemi di stabilità, perché non esiste un filtro ricorsivo, quindi non si accumuleranno errori. In altre parole, il sistema è tutto zeri, nessun polo. Ho sentito aneddoticamente, ma non verificato per me stesso, che la convoluzione basata su FFT ha un errore inferiore rispetto alla convoluzione nel dominio del tempo, semplicemente perché ha operazioni aritmetiche O (n log n) anziché O (n ^ 2).

In genere, per quanto ne so, i filtri Butterworth sono implementati come filtri ricorsivi (IIR), quindi questo è un argomento diverso. I filtri IIR hanno poli e zeri, quindi in pratica possono esserci problemi di stabilità. Inoltre, per i filtri IIR, i metodi basati su FFT non sono un'opzione, ma al rialzo, i filtri IIR tendono ad essere di ordine molto basso.

Per quanto riguarda i problemi di stabilità con i filtri IIR, tendono ad avere problemi a ordini più alti: lancerò un numero e dirò che circa il 6 ° ordine lo sta spingendo. Invece, sono tipicamente implementati come biquad in cascata (sezioni filtro del 2 ° ordine). Per il filtro del 5 ° ordine, scrivilo come una funzione di trasferimento del dominio z (sarà una funzione razionale di 5 ° grado), quindi fattorizzalo nei suoi 5 poli e 5 zeri. Raccogli i coniugati complessi e avrai due biquad e un filtro del primo ordine. In generale, i problemi di stabilità tendono a spuntare man mano che i poli si avvicinano al cerchio dell'unità.

Ci possono anche essere problemi con rumore e cicli limite nei filtri IIR, quindi ci sono diverse topologie di filtro (cioè forma diretta I, forma diretta II) che hanno proprietà numeriche diverse, ma non penserei troppo a questo punto - basta usare il doppio- precisione e quasi sicuramente sarà abbastanza buono.

In quasi tutti i casi la scelta migliore non è né convoluzione né FFT, ma semplicemente applicando direttamente il filtro IIR (usando ad esempio la funzione sosfilt ()). Ciò sarà notevolmente più efficiente in termini di consumo di CPU e memoria.

La differenza numerica dipende dal filtro specifico. L'unico caso in cui una certa differenza può insinuarsi è se i poli sono molto, molto vicini al cerchio dell'unità. Anche lì alcuni trucchi che possono aiutare. NON UTILIZZARE la rappresentazione e il filtro della funzione di trasferimento () ma utilizzare poli e zero con sosfilt (). Ecco un esempio per la differenza.

n = 2^16;  % filter length
fs = 44100; % sample rate
x = zeros(n,1); x(1) = 1;
f0 = 15; % cutoff frequency in Hz
% design with poles and zeroes
[z,p,k] = butter(5,f0*2/fs);
clf
plot(sosfilt(zp2sos(z,p,k),x));
% design with transfer function
[b,a] = butter(5,f0*2/fs);
hold on
plot(filter(b,a,x),'k');

filter () si guasta con un cutoff di circa 15Hz @ 44.1kHz. Per sosfilt () il cutoff può essere ben al di sotto di 1/100 di Hz a 44,1 kHz senza problemi.

Se hai problemi di stabilità, anche la FFT non aiuta molto. Poiché il filtro è un filtro IIR, la risposta all'impulso è infinita e dovrebbe essere prima troncata. A queste frequenze molto basse la risposta all'impulso diventa così lunga che anche la FFT diventa poco pratica.

Ad esempio, se si desidera un taglio di 1/100 Hz a 44,1 kHz e si desidera un intervallo dinamico nella risposta all'impulso di 100 dB, sono necessari circa 25 milioni di campioni !!! Sono quasi 10 minuti a 44,1 kHz e molte, molte volte più lunghe del segnale originale

Perché pensi che le cose saranno diverse? I concetti teorici dovrebbero tradursi in applicazioni pratiche, con l'unica differenza che è quella dei problemi in virgola mobile, a cui non possiamo sfuggire. Puoi facilmente verificare con un semplice esempio in MATLAB:

x=randn(5,1);
y=randn(5,1);
X=fft(x,length(x)+length(y)-1);
Y=fft(y,length(x)+length(y)-1);

z1=conv(x,y);z2=ifft(X.*Y);
z1-z2

ans =

   1.0e-15 *

   -0.4441
   -0.6661
         0
   -0.2220
    0.8882
   -0.2220
         0
   -0.4441
    0.8882

Come puoi vedere, gli errori sono dell'ordine della precisione della macchina. Non ci dovrebbero essere motivi per non usare il metodo FFT. Come menzionato da Endolith, è molto più comune utilizzare l'approccio FFT per filtrare / convolgere / correlare in modo incrociato, ecc. E molto più velocemente, tranne che per campioni molto piccoli (come in questo esempio). Non che l'elaborazione nel dominio del tempo non venga mai eseguita ... tutto si riduce all'applicazione, alle esigenze e ai vincoli.