Có được giá trị cực đại của tín hiệu nếu tần số nằm giữa hai tâm bin

Hãy giả sử như sau:

• Tần số cơ bản của tín hiệu đã được ước tính bằng FFT và một số phương pháp ước tính tần số và nằm giữa hai trung tâm bin
• Tần suất lấy mẫu là cố định
• Nỗ lực tính toán không phải là một vấn đề

Biết tần số, cách chính xác nhất để ước tính giá trị đỉnh tương ứng của các tín hiệu cơ bản là gì?

Một cách có thể là không đệm tín hiệu thời gian để tăng độ phân giải FFT sao cho tâm bin sẽ gần với tần số ước tính hơn. Trong kịch bản này, một điểm tôi không chắc chắn là liệu tôi có thể zero-pad nhiều như tôi muốn hay không nếu có một số hạn chế khi làm như vậy. Một cái khác là trung tâm bin mà tôi nên chọn sau khi đệm bằng 0 là giá trị tôi nhận được giá trị cực đại từ (vì người ta có thể không đạt được tần suất quan tâm chính xác, ngay cả sau khi đệm không).

Tuy nhiên, tôi cũng tự hỏi liệu có một phương pháp nào khác có thể mang lại kết quả tốt hơn không, đó là một công cụ ước tính sử dụng các giá trị đỉnh của hai trung tâm bin xung quanh để ước tính giá trị đỉnh theo tần suất quan tâm.

Thuật toán đầu tiên nảy ra trong đầu là Thuật toán Goertzel . Thuật toán đó thường giả định rằng tần suất quan tâm là bội số nguyên của tần số cơ bản. Tuy nhiên, bài viết này áp dụng thuật toán (tổng quát) cho trường hợp bạn quan tâm.

Một vấn đề khác là mô hình tín hiệu không chính xác. Nó sử dụng 2*%pi*(1:siglen)*(Fc/siglen). Nó nên sử dụng 2*%pi*(0:siglen-1)*(Fc/siglen)cho pha đi ra chính xác.

Tôi cũng nghĩ rằng có một vấn đề với tần số Fc=21.3rất thấp. Các tín hiệu có giá trị thực tần số thấp có xu hướng biểu hiện sai lệch khi gặp các vấn đề ước tính pha / tần số.

Tôi cũng đã thử tìm kiếm lưới thô cho ước tính pha và nó cho câu trả lời giống như thuật toán Goertzel.

Dưới đây là một biểu đồ cho thấy độ lệch trong cả hai ước tính (Goertzel: xanh lam, Coough: đỏ) cho hai tần số khác nhau: Fc=21.3(solid) và Fc=210.3(nét đứt). Như bạn có thể thấy độ lệch cho tần số cao hơn là ít hơn nhiều.

Biểu đồ -axis là pha ban đầu thay đổi từ 0 đến 2 π .$x$$2\pi$

Nếu bạn sẵn sàng sử dụng nhiều thùng FFT lân cận, không chỉ 2, thì cửa sổ Nội suy giữa các kết quả bin phức tạp có thể tạo ra ước tính rất chính xác, tùy thuộc vào độ rộng của cửa sổ.

Nội suy Windowed Sinc thường được tìm thấy trong các bộ tăng âm thanh chất lượng cao, do đó, các bài viết về chủ đề đó sẽ có các công thức nội suy phù hợp với phân tích lỗi.

[1] JL Flanagan và RM Golden, bộ phát âm Giai đoạn, Tạp chí Kỹ thuật của Bell Bell Systems, tập. 45, trang 14931501509, 1966.

[2] K. Dressler, chiết xuất hình sin bằng cách sử dụng một triển khai hiệu quả của một FFT đa độ phân giải, vì trong Proc. Ngày 9 Conf. trên Hiệu ứng âm thanh kỹ thuật số (DAFx-06), Montreal, Canada, tháng 9 năm 2006, trang 247.

Một phương pháp là tìm tối đa và phù hợp với một parabol về nó, và sau đó sử dụng tối đa của parabola làm ước tính tần số và cường độ. Bạn có thể đọc tất cả về đây: https://ccrma.stanford.edu/~jos/sasp/Sinusoidal_Peak_Interpolation.html

Tôi đã gặp rất nhiều khó khăn với vấn đề chính xác này một vài năm trước đây.

Tôi đã đăng câu hỏi này:

/programming/4633203/extracting-precise-frequencies-from-fft-bins-USE-phase-change-b between-framework

Tôi đã kết thúc việc tính toán từ đầu, và đăng một câu trả lời cho câu hỏi của riêng tôi.

Tôi ngạc nhiên rằng tôi không thể tìm thấy bất kỳ giải trình tương tự nào trên Internet.

Tôi sẽ đăng câu trả lời một lần nữa ở đây; lưu ý rằng mã được thiết kế cho một kịch bản trong đó tôi chồng chéo cửa sổ FFT của mình lên gấp 4 lần.

π

Câu đố này có hai chìa khóa để mở khóa nó.

• Chìa khóa đầu tiên là hiểu cách chồng chéo cửa sổ FFT giới thiệu một vòng quay trên pha bin.

• Khóa thứ hai đến từ Biểu đồ 3.3 & 3.4 tại đây (cảm ơn Stephan Bernsee đã cho phép sao chép các bức ảnh ở đây).

Biểu đồ 3.3:

Biểu đồ 3,4:

Mã số:

for (int k = 0; k <= fftFrameSize/2; k++) 
{
    // compute magnitude and phase 
    bins[k].mag = 2.*sqrt(fftBins[k].real*fftBins[k].real + fftBins[k].imag*fftBins[k].imag);
    bins[k].phase = atan2(fftBins[k].imag, fftBins[k].real);

    // Compute phase difference Δϕ fo bin[k]
    double deltaPhase;
    {
        double measuredPhaseDiff = bins[k].phase - gLastPhase[k];
        gLastPhase[k] = bins[k].phase;

        // Subtract expected phase difference <-- FIRST KEY
        // Think of a single wave in a 1024 float frame, with osamp = 4
        //   if the first sample catches it at phase = 0, the next will 
        //   catch it at pi/2 ie 1/4 * 2pi
        double binPhaseExpectedDiscrepancy = M_TWOPI * (double)k / (double)osamp;
        deltaPhase = measuredPhaseDiff - binPhaseExpectedDiscrepancy;

        // Wrap delta phase into [-Pi, Pi) interval 
        deltaPhase -= M_TWOPI * floor(deltaPhase / M_TWOPI + .5);
    }

    // say sampleRate = 40K samps/sec, fftFrameSize = 1024 samps in FFT giving bin[0] thru bin[512]
    // then bin[1] holds one whole wave in the frame, ie 44 waves in 1s ie 44Hz ie sampleRate / fftFrameSize
    double bin1Freq = (double)sampleRate / (double)fftFrameSize;
    bins[k].idealFreq = (double)k * bin1Freq;

    // Consider Δϕ for bin[k] between hops.
    // write as 2π / m.
    // so after m hops, Δϕ = 2π, ie 1 extra cycle has occurred   <-- SECOND KEY
    double m = M_TWOPI / deltaPhase;

    // so, m hops should have bin[k].idealFreq * t_mHops cycles.  plus this extra 1.
    // 
    // bin[k].idealFreq * t_mHops + 1 cycles in t_mHops seconds 
    //   => bins[k].actualFreq = bin[k].idealFreq + 1 / t_mHops
    double tFrame = fftFrameSize / sampleRate;
    double tHop = tFrame / osamp;
    double t_mHops = m * tHop;

    bins[k].freq = bins[k].idealFreq + 1. / t_mHops;
}

Mã trăn này sẽ cho bạn một kết quả rất chính xác (tôi đã sử dụng nó cho rất nhiều nốt nhạc và nhận được sai số nhỏ hơn 0,01% semitone) với phép nội suy parabol (phương pháp được sử dụng bởi McAulay Quatieri, Serra, v.v. kỹ thuật tách)

import matplotlib.pyplot as plt
import numpy as np
from scipy.io.wavfile import read
from scipy.fftpack import fft, ifft
import math

(fs, x) = read('test.wav')
if (len(x.shape) == 2):    # if stereo we keep left channel only
 x = x[:,1]

n=x.size
freq = np.arange(n)*1.0/n*fs 
xfft = abs(fft(x))

imax=np.argmax(xfft)  
p=1.0/2*(xfft[imax-1]/xfft[imax]-xfft[imax+1]/xfft[imax])/(xfft[imax-1]/xfft[imax]-2+xfft[imax+1]/xfft[imax])   # parabolic interpolation 
print 'Frequence detectee avec interpolation parabolique :',(imax+p)*1.0/n*fs, 'Hz'

clear all
clc

for phase_orig = 0:pi/18:pi,

%% Specify and generate signal
Amp = 1;                     % Amplitude of signal
Fs = 8000;                   % samples per second
dt = 1/Fs;                   % seconds per sample
Fc = 21.3;                   % Hz
StopTime = 0.25;             % seconds
t = (0:dt:StopTime-dt)';     % seconds

siglen = length(t);
sig = Amp * 1.5 * sin(2*pi*(0:siglen-1)*(Fc/siglen) + phase_orig) + 1.5 * Amp * sin(2*pi*(0:siglen-1)*(Fc/siglen) * 3) ...
  + 1.5 * Amp * sin(2*pi*(0:siglen-1)*(Fc/siglen) * 5)+ 0.3 * Amp * sin(2*pi*(0:siglen-1)*(Fc/siglen) * 7) ...
  + 1.3 * Amp * sin(2*pi*(0:siglen-1)*(Fc/siglen) * 9)+ 1.4 * Amp * sin(2*pi*(0:siglen-1)*(Fc/siglen) * 11);

%% Estimate the peak value of the signals fundamental using Goertzel algorithm
peak = 0;
indvec = [Fc-1 Fc Fc+1];

% Check the input data
if ~isvector(sig) || isempty(sig)
  error('X must be a nonempty vector')
end

if ~isvector(indvec) || isempty(indvec)
  error('INDVEC must be a nonempty vector')
end
if ~isreal(indvec)
  error('INDVEC must contain real numbers')
end

% forcing x to be column
sig = reshape(sig,siglen,1);

% initialization
no_freq = length(indvec); %number of frequencies to compute
y = zeros(no_freq,1); %memory allocation for the output coefficients

% Computation via second-order system
% loop over the particular frequencies
for cnt_freq = 1:no_freq
  %for a single frequency:
  %a/ precompute the constants
  pik_term = 2*pi*(indvec(cnt_freq))/(siglen);
  cos_pik_term2 = cos(pik_term) * 2;
  cc = exp(-1i*pik_term); % complex constant
  %b/ state variables
  s0 = 0;
  s1 = 0;
  s2 = 0;
  %c/ 'main' loop
  for ind = 1:siglen-1 %number of iterations is (by one) less than the length of signal
    %new state
    s0 = sig(ind) + cos_pik_term2 * s1 - s2;  % (*)
    %shifting the state variables
    s2 = s1;
    s1 = s0;
  end
  %d/ final computations
  s0 = sig(siglen) + cos_pik_term2 * s1 - s2; %correspond to one extra performing of (*)
  y(cnt_freq) = s0 - s1*cc; %resultant complex coefficient

  %complex multiplication substituting the last iterationA
  %and correcting the phase for (potentially) non-integer valued
  %frequencies at the same time
  y(cnt_freq) = y(cnt_freq) * exp(-1i*pik_term*(siglen-1));
end

  % perfom amplitude scaling
  peak = abs(y(2)) * 2 / siglen

% perform parabolic interpolation to get the phase estimate
phase_orig=phase_orig*180/pi
ym1 = angle(unwrap(y(1)));
y0 = angle(unwrap(y(2)));
yp1 = angle(unwrap(y(3)));

p = (yp1 - ym1)/(2*(2*y0 - yp1 - ym1)); 
phase = y0 - 0.25*(ym1-yp1)*p;
phase_est = phase * 180/pi + 90;
phase_est = mod(phase_est+180,360)-180
end

Tần số bạn đang xử lý (21.3Hz được lấy mẫu ở 8kHz) rất thấp. Vì đây là các tín hiệu có giá trị thực, chúng sẽ thể hiện sai lệch trong ước lượng pha cho ** bất kỳ tần số ** nào.

Hình ảnh này cho thấy một âm mưu của bias ( phase_est - phase_orig) cho Fc = 210.3;(màu đỏ) so với độ lệch cho Fc = 21.3;. Như bạn có thể thấy, phần bù có ý nghĩa hơn nhiều đối với21.3 trường hợp.

Một lựa chọn khác là giảm tỷ lệ lấy mẫu của bạn. Các đường cong màu xanh lá cây cho thấy sự thiên vị cho Fs = 800thay vì 8000.