Reales weißes Gaußsches Rauschen mit dem Mittelwert Null, unabhängig von einem sauberen Signal und bekannter Varianz, wird zu addiert, wodurch ein verrauschtes SignalDie diskrete Fourier-Transformation (DFT) des verrauschten Signals wird berechnet durch:$x$$x$$y.$$Y$

$$Y_k = \frac{1}{N}\sum_{n=0}^{N-1}e^{-i2\pi kn/N}y_n.\tag{1}$$

Dies ist nur für den Kontext gedacht, und wir werden die Rauschvarianz im Frequenzbereich definieren, sodass die Normalisierung (oder deren Fehlen) nicht wichtig ist. Gaußsches weißes Rauschen im Zeitbereich ist Gaußsches weißes Rauschen im Frequenzbereich, siehe Frage: " Wie ist die Statistik der diskreten Fourier-Transformation des weißen Gaußschen Rauschens? ". Deshalb können wir schreiben:

$$Y_k = X_k + Z_k,$$

wobei $X$ und $Z$ die $Z_k$ des sauberen Signals und Rauschens sind und Z_k der Rauschbehälter, der einer zirkular symmetrischen komplexen Gaußschen Varianzverteilung $\sigma^2$ folgt . Jeder Real- und Imaginärteil von $Z_k$ folgt unabhängig voneinander einer Gaußschen Varianzverteilung $\frac{1}{2}\sigma^2$ . Wir definieren das Signal-Rausch-Verhältnis (SNR) von bin $Y_k$ als:

$$\mathrm{SNR} = \frac{\sigma^2}{|X_k|^2}.$$

Ein Versuch, das Rauschen zu reduzieren, wird dann durch spektrale Subtraktion unternommen, wobei die Größe jedes Bin unabhängig wird, während die ursprüngliche Phase beibehalten wird (es sei denn, der Bin-Wert geht bei der auf Null). Die Reduktion bildet eine Schätzung des Quadrats des Absolutwerts jedes Bin der DFT des sauberen Signals:$Y_k$$\widehat{|X_k|^2}$$|X_k|^2$

$$\widehat{|X_k|^2} = |Y_k|^2 - \sigma^2,\tag{2}$$

Dabei ist die bekannte Varianz des Rauschens in jedem DFT-Bin. Der Einfachheit halber berücksichtigen wir nicht oder für gerade , was Sonderfälle für realesBei einem niedrigen SNR kann die Formulierung in (2) manchmal zu einem negativenWir können dieses Problem beheben, indem wir die Schätzung von unten auf Null klemmen und neu definieren:$\sigma^2$$k = 0,$$k = N/2$$N$$x.$$\widehat{| X_k|^2}.$

$$\widehat{|X_k|^2} = \max\left(|Y_k|^2 - \sigma^2,\,0\right).\tag{3}$$

Figure 1. Monte-Carlo-Schätzungen mit einer Stichprobengröße von von: Solid: Gewinn der Summe der quadratischen Fehler bei der Schätzung vondurch im Vergleich zur Schätzung mit gestrichelt: Gewinn der Summe der quadratischen Fehler bei der Schätzung von durch im Vergleich zur Schätzung mit gepunktet: Gewinn der Summe der quadratischen Fehler bei der Schätzung von durch im Vergleich zur Schätzung mitDie Definition von aus (3) wird verwendet.$10^5,$$|X_k|$$\widehat{|X_k|}$$|Y_k|,$$|X_k|^2$$\widehat{|X_k|^2}$$|Y_k|^2,$$X_k$$\widehat{|X_k|}e^{i\arg(Y_k)}$$Y_k.$$\widehat{|X_k|^2}$

Frage: Gibt es eine andere Schätzung vonoder , das (2) und (3) verbessert, ohne sich auf die Verteilung von ?$|X_k|$$|X_k|^2$$Y_k$

Ich denke, das Problem entspricht der Schätzung des Quadrats des Parameters einer Reisverteilung (Abb. 2) mit dem bekannten Parameter gegeben eine einzige Beobachtung.$\displaystyle{\nu_\mathrm{Rice}}$ σ R i c e = √$\sigma_\mathrm{Rice} = \frac{\sqrt{2}}{2}\sigma,$

Abbildung 2. Reisverteilung ist die Verteilung des Abstands zum Ursprung von einem Punkt, der einer bivariaten zirkularsymmetrischen Normalverteilung mit einem Absolutwert des Mittelwerts Varianz folgt und Komponentenvarianz$R$$\nu_\mathrm{Rice},$$2\sigma_\mathrm{Rice}^2 = \sigma^2$$\sigma_\mathrm{Rice}^2 = \frac{1}{2}\sigma^2.$

Ich habe Literatur gefunden, die relevant erscheint:

• Jan Sijbers, Arnold J. den Dekker, Paul Scheunders und Dirk Van Dyck, "Maximum Likelihood Estimation of Rician Distribution Parameters" , IEEE-Transaktionen zur medizinischen Bildgebung (Band: 17, Ausgabe: 3, Juni 1998) ( doi , pdf ).

Python-Skript A für Schätzerkurven

Dieses Skript kann erweitert werden, um Schätzerkurven in den Antworten zu zeichnen.

import numpy as np
from mpmath import mp
import matplotlib.pyplot as plt

def plot_est(ms, est_as):
    fig = plt.figure(figsize=(4,4))
    ax = fig.add_subplot(1, 1, 1)
    if len(np.shape(est_as)) == 2:
        for i in range(np.shape(est_as)[0]):
            plt.plot(ms, est_as[i])
    else:
        plt.plot(ms, est_as)    
    plt.axis([ms[0], ms[-1], ms[0], ms[-1]])
    if ms[-1]-ms[0] < 5:
        ax.set_xticks(np.arange(np.int(ms[0]), np.int(ms[-1]) + 1, 1))
        ax.set_yticks(np.arange(np.int(ms[0]), np.int(ms[-1]) + 1, 1))
    plt.grid(True)
    plt.xlabel('$m$')
    h = plt.ylabel('$\hat a$')
    h.set_rotation(0)
    plt.show()

Python-Skript B für Abb. 1

Dieses Skript kann für Fehlerverstärkungskurven in den Antworten erweitert werden.

import math
import numpy as np
import matplotlib.pyplot as plt

def est_a_sub_fast(m):
    if m > 1:
        return np.sqrt(m*m - 1)
    else:
        return 0

def est_gain_SSE_a(est_a, a, N):
    SSE = 0
    SSE_ref = 0
    for k in range(N):  #Noise std. dev = 1, |X_k| = a
        m = abs(complex(np.random.normal(a, np.sqrt(2)/2), np.random.normal(0, np.sqrt(2)/2)))
        SSE += (a - est_a(m))**2 
        SSE_ref += (a - m)**2
    return SSE/SSE_ref

def est_gain_SSE_a2(est_a, a, N):
    SSE = 0
    SSE_ref = 0
    for k in range(N):  #Noise std. dev = 1, |X_k| = a
        m = abs(complex(np.random.normal(a, np.sqrt(2)/2), np.random.normal(0, np.sqrt(2)/2)))
        SSE += (a**2 - est_a(m)**2)**2
        SSE_ref += (a**2 - m**2)**2
    return SSE/SSE_ref

def est_gain_SSE_complex(est_a, a, N):
    SSE = 0
    SSE_ref = 0
    for k in range(N):  #Noise std. dev = 1, X_k = a
        Y = complex(np.random.normal(a, np.sqrt(2)/2), np.random.normal(0, np.sqrt(2)/2))        
        SSE += abs(a - est_a(abs(Y))*Y/abs(Y))**2
        SSE_ref += abs(a - Y)**2
    return SSE/SSE_ref

def plot_gains_SSE(as_dB, gains_SSE_a, gains_SSE_a2, gains_SSE_complex, color_number = 0):    
    colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
    fig = plt.figure(figsize=(7,4))
    ax = fig.add_subplot(1, 1, 1)
    if len(np.shape(gains_SSE_a)) == 2:
        for i in range(np.shape(gains_SSE_a)[0]):
            plt.plot(as_dB, gains_SSE_a[i], color=colors[i], )
            plt.plot(as_dB, gains_SSE_a2[i], color=colors[i], linestyle='--')
            plt.plot(as_dB, gains_SSE_complex[i], color=colors[i], linestyle=':')
    else:
        plt.plot(as_dB, gains_SSE_a, color=colors[color_number])
        plt.plot(as_dB, gains_SSE_a2, color=colors[color_number], linestyle='--')
        plt.plot(as_dB, gains_SSE_complex, color=colors[color_number], linestyle=':')
    plt.grid(True)
    plt.axis([as_dB[0], as_dB[-1], 0, 2])
    plt.xlabel('SNR (dB)')
    plt.ylabel('SSE gain')
    plt.show()

as_dB = range(-40, 41)
as_ = [10**(a_dB/20) for a_dB in as_dB]
gains_SSE_a_sub = [est_gain_SSE_a(est_a_sub_fast, a, 10**5) for a in as_]
gains_SSE_a2_sub = [est_gain_SSE_a2(est_a_sub_fast, a, 10**5) for a in as_]
gains_SSE_complex_sub = [est_gain_SSE_complex(est_a_sub_fast, a, 10**5) for a in as_]

plot_gains_SSE(as_dB, gains_SSE_a_sub, gains_SSE_a2_sub, gains_SSE_complex_sub, 1)

Maximum Likelihood (ML) Schätzer

Hier wird ein Maximum-Likelihood-Schätzer für die Leistung des sauberen Signals abgeleitet, der jedoch die Ergebnisse hinsichtlich des quadratischen Mittelwertfehlers für jedes SNR im Vergleich zur spektralen Leistungssubtraktion nicht verbessert.

Einführung

Lassen Sie uns die normalisierte saubere Amplitude und die normalisierte verrauschte Größe einführen, die durch die Rauschstandardabweichung normalisiert sind$a$$m$$\sigma:$

$$a = \frac{|X_k|}{\sigma},\quad m = \frac{|Y_k|}{\sigma}.\tag{1}$$

Der Schätzer in Gl. 3 der Frage gibt eine Schätzung von als:$\hat a$$a$

$$\hat a = \frac{1}{\sigma}\sqrt{\widehat{|X_k|^2}} = \frac{1}{\sigma}\sqrt{\max\left((\sigma m)^2 - \sigma^2, 0\right)} = \cases{\sqrt{m^2-1}&if $m > 1,$\\0&if $m \le 1.$}\tag{2}$$

Maximum Likelihood Estimator

Um einen möglicherweise besseren Schätzer für als Gl. 2 folgen wir dem Verfahren von Sijbers et al. 1998. (siehe Frage), um einen Maximum-Likelihood (ML) -Schätzer zu konstruierenEs gibt den Wert von , der die Wahrscheinlichkeit des gegebenen Wertes von maximiert$a$a$\hat{a}_\mathrm{ML}.$$a$$m.$

Das PDF vonist Rician mit dem Parameterund Parameter (der Klarheit später zu ersetzen)$|Y_k|$ν R i c e = | X k$\nu_\mathrm{Rice} = |X_k|$$\sigma_\mathrm{Rice} = \frac{1}{\sqrt{2}}\sigma:$

$$\mathrm{PDF}(|Y_k|) = \frac{|Y_k|}{\sigma_\mathrm{Rice}^2}\exp\left(\frac{-\left(|Y_k|^2 + |X_k|^2\right)}{2\sigma_\mathrm{Rice}^2}\right)I_0\left(\frac{|Y_k||X_k|}{\sigma_\mathrm{Rice}^2}\right),\tag{3}$$

wobei eine modifizierte Bessel-Funktion der ersten Art ist . Ersetzen von und$I_\alpha$| X k | = σ a , | Y k | = σ m , σ 2 R i c e = 1$|X_k| = \sigma a,$ $|Y_k| = \sigma m,$$\sigma_\mathrm{Rice}^2 = \frac{1}{2}\sigma^2:$

$$= \mathrm{PDF}(\sigma m) = \frac{2m}{\sigma}e^{-\left(m^2 + a^2\right)}I_0(2ma),\tag{3.1}$$

und verwandeln:

$$\Rightarrow \mathrm{PDF}(m) = \sigma\mathrm{PDF}(\sigma m) = 2m e^{-\left(m^2 + a^2\right)}I_0(2ma).\tag{3.2}$$

Das durch parametrisierte Rician-PDF von ist unabhängig von der RauschvarianzDer Maximum-Likelihood-Schätzer von Parameter ist der Wert von , der maximiert . Es ist eine Lösung von:$m$$a$$\sigma^2.$$\hat a_\mathrm{ML}$$a$$a$$\mathrm{PDF}(m)$

$$m\frac{I_1(2m\hat a_\mathrm{ML})}{I_0(2m\hat a_\mathrm{ML})} - \hat a_\mathrm{ML} = 0.\tag{4}$$

Die Lösung zu Gl. 4 hat die Eigenschaft, dass:

$$\hat a_\mathrm{ML} = 0\quad\text{ if }\quad m \le 1.\tag{5}$$

Andernfalls muss es numerisch gelöst werden.

Abbildung 1. blau, oben: der Maximum-Likelihood-Schätzer und orange, unten: der Leistungsspektral-Subtraktionsschätzer der Frage der normalisierten sauberen Amplitude als Funktion der normalisierten verrauschten Größe$\hat a_\mathrm{ML}$$\hat a$$a$$m.$

$\sigma\hat a_\mathrm{ML}$ ist der Maximum-Likelihood-Schätzer von und durch funktionale Invarianz der Maximum-Likelihood-Schätzung ist der Maximum-Likelihood-Schätzer von$|X_k|,$$\sigma^2\hat a_\mathrm{ML}^2$$|X_k|^2.$

Empirische Laurent-Reihe des ML-Schätzers

Ich habe versucht, die Laurent-Reihe von numerisch zu berechnen (siehe Skript weiter unten) aber sie scheint nicht für den Bereich von zu konvergieren . Hier ist eine Kürzung der Laurent-Reihe, soweit ich sie berechnet habe:$\hat a_\mathrm{ML}^2,$$m$

$$\hat a_\mathrm{ML}^2 \approx m^2 - \frac{1}{2^1m^0} - \frac{1}{2^3m^2} - \frac{3}{2^5m^4} - \frac{12}{2^7m^6} - \frac{57}{2^9m^8} - \frac{309}{2^{11}m^{10}} - \frac{1884}{2^{13}m^{12}} - \frac{12864}{2^{15}m^{14}} - \frac{98301}{2^{17}m^{16}} - \frac{839919}{2^{19}m^{18}} - \frac{7999311}{2^{21}m^{20}}\tag{6}$$

Ich konnte die Zähler- oder Nenner-Ganzzahlsequenzen in der Online-Enzyklopädie der Ganzzahlsequenzen (OEIS) nicht finden. Nur für die ersten fünf Terme mit negativer Leistung stimmen die Zählerkoeffizienten mit A027710 überein . Nachdem ich die berechnete Sequenz ( ) an OEIS Superseeker gesendet hatte , erhielt ich dies in der Antwort (von der ich die nächsten drei vorgeschlagenen Nummern durch eine erweiterte Berechnung):$1, -1, -1, -3, \ldots$$-84437184, -980556636, -12429122844$

Guesss suggests that the generating function  F(x)
may satisfy the following algebraic or differential equation:

-1/2*x+1/2+(-x+1/2)*x*diff(F(x),x)+(x-3/2)*F(x)-1/2*F(x)*x*diff(F(x),x)+F(x)^2 = 0

If this is correct the next 6 numbers in the sequence are:

[-84437184, -980556636, -12429122844, -170681035692, -2522486871192, -39894009165525]

Tabellarische Annäherung und Schätzfehlerverstärkung

Eine linear interpolierte Tabelle (siehe Skripte unten), die ungleichmäßig verteilte Stichproben von ergibt eine Näherung mit einem maximalen Fehler von ungefähr$124071$$\hat a_\mathrm{ML}^2-m^2$$6\times10^{-11}.$

Approximation der kleinsten Quadrate des ML-Schätzers

Eine Näherung der kleinsten Quadrate (mit zusätzlichem Gewicht bei ) der Stichproben der Schätzerkurve wurde in einer Form erstellt, die von den Experimenten der Laurent-Reihe inspiriert wurde (siehe Oktavschrift weiter unten). Der konstante Term wurde geändert, um die Möglichkeit eines negativen bei zu beseitigen Die Näherung gilt für und hat einen maximalen Fehler von ungefähr (Abb 3) bei der Annäherung von$m^2 = 1$- 0.5- 0.49999998237308493999$a^2$$m^2 = 1.$$m^2 \ge 1$$2\times10^{-5}$$\hat a_\mathrm{ML}^2:$

a^2 = m^2 - 0.49999998237308493999 -0.1267853520007855/m^2 - 0.02264263789612356/m^4 - 1.008652066326489/m^6 + 4.961512935048501/m^8 - 12.27301424767318/m^10 + 5.713416605734312/m^12 + 21.55623892529696/m^14 - 38.15890985013438/m^16 + 24.77625343690267/m^18 - 5.917417766578400/m^20

Abbildung 3. Fehler der Approximation der kleinsten Quadrate von$\hat a_\mathrm{ML}^2.$

Das Skript scheint in der Lage zu sein, die Anzahl der negativen Potenzen von erhöhen wobei immer kleinere Fehler auftreten, wobei die Anzahl der Extrema-Fehler zunimmt, jedoch mit einem recht langsamen maximalen Fehlerabfall. Die Annäherung ist fast gleich, würde aber dennoch ein wenig von der Verfeinerung des Remez-Austauschs profitieren .$m^2,$

Unter Verwendung der Näherung wurden die folgenden erwarteten Fehlerverstärkungskurven erhalten:

Abbildung 2. Monte-Carlo-Schätzungen mit einer Stichprobengröße von von: Solid: Gewinn der Summe der quadratischen Fehler bei der Schätzung vondurch im Vergleich zur Schätzung mit gestrichelt: Gewinn der Summe der quadratischen Fehler bei der Schätzung von durch im Vergleich zur Schätzung mit gepunktet: Gewinn der Summe der quadratischen Fehler bei der Schätzung von durch im Vergleich zur Schätzung mitBlau: ML-Schätzer, Orange: geklemmte spektrale Leistungssubtraktion.$10^5,$$|X_k|$$\widehat{|X_k|}$$|Y_k|,$$|X_k|^2$$\widehat{|X_k|^2}$$|Y_k|^2,$$X_k$$\widehat{|X_k|}e^{i\arg(Y_k)}$$Y_k.$

Überraschenderweise ist der ML-Schätzer in fast allen Aspekten schlechter als die geklemmte spektrale Leistungssubtraktion, außer dass er für die Signalschätzung bei SNR> etwa 5 dB und die Amplitudenschätzung bei SNR> etwa 3 dB geringfügig besser ist. Bei diesen SNR sind die beiden Schätzer schlechter als nur das verrauschte Signal als Schätzung zu verwenden.

Python-Skript A für Abb. 1

Dieses Skript erweitert das Skript A der Frage.

def est_a_sub(m):
    m = mp.mpf(m)
    if m > 1:
        return mp.sqrt(m**2 - 1)
    else:
        return 0

def est_a_ML(m):
    m = mp.mpf(m)
    if m > 1:
        return mp.findroot(lambda a: m*mp.besseli(1, 2*a*m)/(mp.besseli(0, 2*a*m)) - a, [mp.sqrt(2*m**2*(m**2 - 1)/(2*m**2 - 1)), mp.sqrt(m**2-0.5)])
    else:
        return 0

def est_a_ML_fast(m): 
    m = mp.mpf(m)
    if m > 1:
        return mp.sqrt(m**2 - mp.mpf('0.49999998237308493999') - mp.mpf('0.1267853520007855')/m**2 - mp.mpf('0.02264263789612356')/m**4 - mp.mpf('1.008652066326489')/m**6 + mp.mpf('4.961512935048501')/m**8 - mp.mpf('12.27301424767318')/m**10 + mp.mpf('5.713416605734312')/m**12 + mp.mpf('21.55623892529696')/m**14 - mp.mpf('38.15890985013438')/m**16 + mp.mpf('24.77625343690267')/m**18 - mp.mpf('5.917417766578400')/m**20)
    else:
        return 0

ms = np.arange(0, 5.0078125, 0.0078125)
est_as = [[est_a_ML(m) for m in ms], [est_a_sub(m) for m in ms]];
plot_est(ms, est_as)

Python-Skript zur numerischen Berechnung von Laurent-Reihen

Dieses Skript berechnet numerisch die ersten Terme der Laurent-Reihe vonEs basiert auf dem Skript in dieser Antwort .$\hat a_\mathrm{ML}^2-m^2.$

from sympy import *
from mpmath import *
num_terms = 10
num_decimals = 12
num_use_decimals = num_decimals + 5 #Ad hoc headroom
def y(a2):
    return sqrt(m2)*besseli(1, 2*sqrt(a2*m2))/besseli(0, 2*sqrt(a2*m2)) - sqrt(a2)

c = []
h = mpf('1e'+str(num_decimals))
denominator = mpf(2)  # First integer denominator. Use 1 if unsure
denominator_ratio = 4  # Denominator multiplier per step. Use 1 if unsure
print("x")
for i in range(0, num_terms):
    mp.dps = 2*2**(num_terms - i)*num_use_decimals*(i + 2) #Ad hoc headroom
    m2 = mpf('1e'+str(2**(num_terms - i)*num_use_decimals))
    r = findroot(y, [2*m2*(m2 - 1)/(2*m2 - 1),  m2-0.5]) #Safe search range, must be good for the problem
    r = r - m2; # Part of the problem definition
    for j in range(0, i):
        r = (r - c[j])*m2
    c.append(r)
    mp.dps = num_decimals
    print '+'+str(nint(r*h)*denominator/h)+'/('+str(denominator)+'x^'+str(i)+')'
    denominator *= denominator_ratio

Python-Skript zur Tabellierung des ML-Schätzers

Dieses Skript erstellt eine ungleichmäßig abgetastete Tabelle von -Paaren, die für die lineare Interpolation geeignet sind, wobei ungefähr der definierte maximale absolute lineare Interpolationsfehler der Approximation von für den BereichDie Tabellengröße wird automatisch durch Hinzufügen von Stichproben zu den schwierigen Teilen erhöht, bis der Spitzenfehler klein genug ist. Wenn gleich plus einer ganzzahligen Potenz von alle Abtastintervalle Potenzen von Am Ende der Tabelle gibt es einen diskontinuitätsfreien Übergang zu einer großen Näherung$\left[m^2, \hat{a}_\mathrm{ML}^2\right]$$\hat{a}_\mathrm{ML}^2$$m = 0\ldots m_\max.$$m_\max$$2$$2,$$2.$$m$$\hat{a}_\mathrm{ML}^2 = m^2 - \frac{1}{2}.$Wenn benötigt wird, ist es meiner Meinung nach besser, die Tabelle unverändert zu interpolieren und dann die Konvertierung$\hat{a}_\mathrm{ML}$$\hat{a}_\mathrm{ML} = \sqrt{\hat{a}_\mathrm{ML}^2}.$

Leiten Sie die Ausgabe zur Verwendung in Verbindung mit dem nächsten Skript weiter > linear.m.

import sys # For writing progress to stderr (won't pipe when piping output to a file)
from sympy import *
from mpmath import *
from operator import itemgetter
max_m2 = 2 + mpf(2)**31 # Maximum m^2
max_abs_error = 2.0**-34 #Maximum absolute allowed error in a^2
allow_over = 0 #Make the created samples have max error (reduces table size to about 7/10)
mp.dps = 24
print('# max_m2='+str(max_m2))
print('# max_abs_error='+str(max_abs_error))
def y(a2):
    return sqrt(m2)*besseli(1, 2*sqrt(a2*m2))/besseli(0, 2*sqrt(a2*m2)) - sqrt(a2)

# [m2, a2, following interval tested good]
samples = [[0, 0, True], [1, 0, False], [max_m2, max_m2 - 0.5, True]]

m2 = mpf(max_m2)
est_a2 = findroot(y, [2*m2*(m2 - 1)/(2*m2 - 1),  m2-0.5])
abs_error = abs(est_a2 - samples[len(samples) - 1][1])
if abs_error > max_abs_error:
    sys.stderr.write('increase max_m, or increase max_abs_error to '+str(abs_error)+'\n')
    quit()

peak_taken_abs_error = mpf(max_abs_error*allow_over)
while True:
    num_old_samples = len(samples)
    no_new_samples = True
    peak_trial_abs_error = peak_taken_abs_error
    for i in range(num_old_samples - 1):
        if samples[i][2] == False:
            m2 = mpf(samples[i][0] + samples[i + 1][0])/2
            est_a2 = mpf(samples[i][1] + samples[i + 1][1])/2
            a2 = findroot(y, [2*m2*(m2 - 1)/(2*m2 - 1),  m2-0.5])
            est_abs_error = abs(a2-est_a2)
            if peak_trial_abs_error < est_abs_error:
                peak_trial_abs_error = est_abs_error
            if est_abs_error > max_abs_error:                
                samples.append([m2, a2 + max_abs_error*allow_over, False])
                no_new_samples = False
            else:
                samples[i][2] = True
                if peak_taken_abs_error < est_abs_error:
                    peak_taken_abs_error = est_abs_error
    if no_new_samples == True:
        sys.stderr.write('error='+str(peak_taken_abs_error)+', len='+str(len(samples))+'\n')
        print('# error='+str(peak_taken_abs_error)+', len='+str(len(samples)))
        break
    sys.stderr.write('error='+str(peak_trial_abs_error)+', len='+str(len(samples))+'\n')
    samples = sorted(samples, key=itemgetter(0))

print('global m2_to_a2_table = [')
for i in range(len(samples)):
    if i < len(samples) - 1:
      print('['+str(samples[i][0])+', '+str(samples[i][1])+'],')
    else:
      print('['+str(samples[i][0])+', '+str(samples[i][1])+']')
print('];')

Python-Skript B für Abb. 2

Dieses Skript erweitert das Skript B der Frage.

def est_a_ML_fast(m): 
    mInv = 1/m
    if m > 1:
        return np.sqrt(m**2 - 0.49999998237308493999 - 0.1267853520007855*mInv**2 - 0.02264263789612356*mInv**4 - 1.008652066326489*mInv**6 + 4.961512935048501*mInv**8 - 12.27301424767318*mInv**10 + 5.713416605734312*mInv**12 + 21.55623892529696*mInv**14 - 38.15890985013438*mInv**16 + 24.77625343690267*mInv**18 - 5.917417766578400*mInv**20)
    else:
        return 0

gains_SSE_a_ML = [est_gain_SSE_a(est_a_ML_fast, a, 10**5) for a in as_]
gains_SSE_a2_ML = [est_gain_SSE_a2(est_a_ML_fast, a, 10**5) for a in as_]
gains_SSE_complex_ML = [est_gain_SSE_complex(est_a_ML_fast, a, 10**5) for a in as_]
plot_gains_SSE(as_dB, [gains_SSE_a_ML, gains_SSE_a_sub], [gains_SSE_a2_ML, gains_SSE_a2_sub], [gains_SSE_complex_ML, gains_SSE_complex_sub])

Oktavskript für kleinste Quadrate

Dieses Oktavskript (eine Anpassung dieser Antwort ) passt die kleinsten Quadrate der Potenzen von in . Die Beispiele wurden vom Python-Skript etwas oben vorbereitet.$m^2$$\hat{a}_\mathrm{ML}^2 - (m^2 - \frac{1}{2})$

graphics_toolkit("fltk");
source("linear.m");
format long
dup_zero = 2000000  # Give extra weight to m2 = 1, a2 = 0
max_neg_powers = 10  # Number of negative powers in the polynomial
m2 = m2_to_a2_table(2:end-1,1);
m2 = vertcat(repmat(m2(1), dup_zero, 1), m2);
A = (m2.^-[1:max_neg_powers]);
a2_target = m2_to_a2_table(2:end-1,2);
a2_target = vertcat(repmat(a2_target(1), dup_zero, 1), a2_target);
fun_target = a2_target - m2 + 0.5;
disp("Cofficients for negative powers of m^2:")
x = A\fun_target
a2 = A*x + m2 - 0.5;
plot(sqrt(m2), sqrt(a2)) # Plot approximation
xlim([0, 3])
ylim([0, 3])
a2(1)  # value at m2 = 2
abs_residual = abs(a2-a2_target);
max(abs_residual) # Max abs error of a^2
max(abs(sqrt(a2)-sqrt(a2_target))) # Max abs error of a
plot(sqrt(log10(m2)), a2_target - a2) # Plot error
xlabel("sqrt(log(m^2))")
ylabel("error in approximation of hat a^2_{ML}")

Python-Skript A2 zur Approximation mit Chebyshev-Polynomen

Dieses Skript erweitert Skript A und gibt eine alternative Annäherung an den ML-Schätzer unter Verwendung von Chebyshev-Polynomen. Der erste Chebyshev-Knoten liegt bei$m=1$ und die Anzahl der Chebyshev-Polynome ist so, dass die Approximation nicht negativ ist.

N = 20
est_a_ML_poly, err = mp.chebyfit(lambda m2Reciprocal: est_a_ML(mp.sqrt(1/m2Reciprocal))**2 - 1/m2Reciprocal, [0, 2/(mp.cos(mp.pi/(2*N)) + 1)], N, error=True)

def est_a_ML_fast(m): 
    global est_a_ML_poly
    m = mp.mpf(m)
    if m > 1:
        return mp.sqrt(m**2 + mp.polyval(est_a_ML_poly, 1/m**2))
    else:
        return 0

Aktualisieren:

Es tut mir leid sagen zu müssen, dass das Testen zeigt, dass das folgende Argument unter starkem Lärm zusammenzubrechen scheint. Das habe ich nicht erwartet, also habe ich definitiv etwas Neues gelernt. Meine vorherigen Tests lagen alle im hohen SNR-Bereich, da ich mich darauf konzentriert habe, im geräuschlosen Fall genaue Lösungen zu finden.

---

Olli,

Wenn Ihr Ziel darin besteht, die Parameter eines reinen Tons in einem verrauschten Signal zu finden, sollten Sie dies gesagt haben. In dieser Ausgabe habe ich viel Erfahrung und Fachwissen.

Sie sagen, Sie suchen nach der Amplitude (und der Phase, die damit einhergeht), also wette ich, dass Sie Ihre DFT auf eine ganze Anzahl von Zyklen ausrichten. Dies ist die schlechteste Konfiguration für diese Situation, da Sie dann Ihr Signal in nur einem einzigen Bin gegen das Rauschen in diesem einzelnen Bin verarbeiten.

Wie Sie oben gezeigt haben, ist Ihr Trick umso schlechter, je größer das SNR ist, bis es nachteilig oder darüber hinaus ist. Nun, Ihr interessierender Behälter wird derjenige mit dem höchsten SNR sein.

Was Sie tun möchten, ist, Ihren DFT-Rahmen auf einen ganzen plus einen halben Zyklus auszurichten. Dadurch wird Ihr Signal auf so viele Bins wie möglich verteilt. Dann finden Sie die Phase und Amplitude, wie in meinem Blog-Artikel zum Thema Phasen- und Amplitudenberechnung für einen reinen Realton in einer DFT beschrieben: Methode 1 .

Kurz gesagt, Sie behandeln die Gruppe von Bins in der Nähe des Peaks als komplexen Vektorraum. Wenn Sie dann die Frequenz kennen, konstruieren Sie einen Satz Basisvektoren für Ihr Signal. Die Koeffizienten der Vektoren fungieren als virtueller Bin, der Ihnen die Amplitude des Signals sowie die Phase anzeigt. Durch das Finden des Best-Fit-Vektors über mehrere Bins hinweg lässt die Technik nicht zu, dass das Rauschen in einem bestimmten Bin zu dominant ist, und bietet sozusagen einen "Hebel", um den sich das Rauschen ausgleichen muss. Die Rauschunterdrückungseffekte ähneln denen, wenn Zufallsvariablen zusammen gemittelt werden.

Um die Basisvektoren zu konstruieren, müssen Sie die DFT eines Sinus und Cosinus mit Ihrer Frequenz nehmen. Ich habe eine Formel für ihre direkte Berechnung, die die Summierung umgeht. Der Artikel dazu ist aus dem obigen Artikel verlinkt.

Ich würde gerne herausfinden, ob Ihre Technik die Ergebnisse dieser Methode verbessert. Ich bin es gewohnt, in einem höheren SNR >> 1 zu arbeiten, daher habe ich nie wirklich getestet, mit welchen Geräuschpegeln Sie es zu tun haben.

Zusammenfassung des Ansatzes:

$$x[n] = a \cdot \cos( \omega n ) + b \cdot \sin( \omega n ) + wgn[n]$$

Weil die DFT ein linearer Operator ist:

$$DFT( x[n] ) = a \cdot DFT( \cos( \omega n ) ) + b \cdot DFT( \sin( \omega n ) ) + DFT( wgn[n] )$$

In Vektornotation:

$$Z = a \cdot A + b \cdot B + W$$

Sie lösen einfach nach $a$ und $b$ mit der linearen Standardalgebra, um die beste Anpassung zu erzielen. Ein Bonus ist, dass Sie auch eine Schätzung von W erhalten. Daher können Sie einen "Throw the Bum Out" -Ansatz ausprobieren und das geschätzte Rauschen im schlecht passenden Behälter vollständig eliminieren und dann neu berechnen. Spülen, wiederholen. Oder reduzieren Sie das Rauschen in jedem Behälter durch eine andere Formel. Wenn Sie dies proportional tun, bleiben Ihre Ergebnisse dieselben wie W orthogonal zu A und B. Eine konstante Subtraktion entlang W anstelle von Z (wie bei Ihrer Methode) sollte jedoch auch die Ergebnisse verbessern.

Normalerweise mache ich die vier Bins um den Peak herum, aber vielleicht möchten Sie das auf 6 oder sogar 8 erweitern. Irgendwann führen mehr Bins zu schlechteren Ergebnissen, da Sie mehr Rauschen als Signal einbringen.

Sie müssen nur die interessierenden DFT-Bins berechnen.

Eine interessante Näherungslösung des Maximum-Likelihood (ML) -Schätzproblems wird unter Verwendung der asymptotischen Formel erhalten

$$I_0(x)\approx \frac{e^x}{\sqrt{2\pi x}},\qquad x\gg 1\tag{1}$$

Unter Verwendung der Notation und der Formeln aus Ollis Antwort erfüllt die optimale ML-Schätzung der normalisierten sauberen Signalamplitude

$$\hat{a}=m\frac{I_1(2m\hat{a})}{I_0(2m\hat{a})}\tag{2}$$

Unter Verwendung von $(1)$ und unter Hinweis darauf, dass $I_1(x)=I_0'(x)$ , erhalten wir die Näherung

$$\frac{I_1(x)}{I_0(x)}\approx 1-\frac{1}{2x}\tag{3}$$

Diese Näherung hat einen relativen Fehler von weniger als $1$ % für $x>4.5$ .

Das Einstecken von $(3)$ in $(2)$ ergibt die Näherungslösung

$$\hat{a}\approx\frac12\left(m+\sqrt{m^2-1}\right)\tag{4}$$

Mit $m=|Y_k|/\sigma$ und $a=|X_k|/\sigma$ wir

$$\widehat{|X|_k}\approx\frac12\left(|Y_k|+\sqrt{|Y_k|^2-\sigma^2}\right)\tag{5}$$

Das ist einfach das arithmetische Mittel der verrauschten Beobachtung $|Y_k|$und die Schätzung, die aus der spektralen Leistungssubtraktion erhalten wird.

---

BEARBEITEN:

Es wäre schön, eine Annäherung wie $(3)$ , die über den gesamten Bereich $x\in[0,\infty)$ funktioniert . Ein Kandidat für eine solche Annäherung ist die Funktionsfamilie

$$f(x)=\frac{x}{\sqrt{c_1+c_2x^2}}\tag{6}$$

$c_1=4$$c_2=1$$f(x)$$x=0$$x\rightarrow\infty$$x$

$(6)$$c_1=4$$c_2=1$

$$\hat{a}=m\sqrt{1-\frac{1}{m^4}}\tag{7}$$

oder äquivalent,

$$\widehat{|X|_k}=|Y_k|\sqrt{1-\frac{\sigma^4}{|Y_k|^4}}\tag{8}$$

---

Ollis Bearbeitung:

$\hat a_\text{ML}$$m.$$a = m$$m\to\infty$$m$$\hat a_\text{ML}^2$$m^2-\frac{1}{2}$$m\to\infty,$$\hat a_\text{ML}$$m\to\infty$$\hat a_\text{ML}^2$$m\to\infty$$-\frac{1}{2}$$\hat a_\text{ML}^2$$c$$\hat a_\text{ML}$$\lim_{m\to\infty}\left(\sqrt{m^2 + c} - m\right) = 0.$

Python-Skript für Abb. 1

Dieses Skript erfordert das Skript der Frage für Modulimporte und für die Plotfunktion plot_estsowie die Funktionsdefinition est_a_MLvon Ollis ML-Antwort.

def est_a_MattL_Eq_4(m):
    m = mp.mpf(m)
    if m > 1:
        return (m + mp.sqrt(m**2 - 1))/2
    else:
        return 0

def est_a_MattL_Eq_7(m):
    m = mp.mpf(m)
    if m > 1:
        return m*mp.sqrt(1 - 1/m**4)
    else:
        return 0

ms = np.arange(0, 2.00390625, 0.00390625)
est_as = [[est_a_MattL_Eq_4(m) for m in ms], [est_a_ML(m) for m in ms], [est_a_MattL_Eq_7(m) for m in ms]];
plot_est(ms, est_as)

ms = np.arange(18, 20.125, 0.125)
est_as = [[est_a_MattL_Eq_4(m) for m in ms], [est_a_ML(m) for m in ms], [est_a_MattL_Eq_7(m) for m in ms]];
plot_est(ms, est_as)

Skaleninvarianter minimaler mittlerer quadratischer Fehler (MMSE) ungeeignete einheitliche vorherige Schätzer der transformierten Amplitude

Diese Antwort präsentiert einen Familienskalen-invarianten Schätzer, der durch einen einzelnen Parameter parametrisiert wird, der sowohl die Bayes'sche vorherige Amplitudenverteilung als auch die Transformation der Amplitude in eine andere Skala steuert. Die Schätzer sind Schätzer für den minimalen mittleren quadratischen Fehler (MMSE) in der transformierten Amplitudenskala. Es wird ein falscher einheitlicher Prior der transformierten Amplitude angenommen. Verfügbare Transformationen umfassen eine lineare Skala (keine Transformation) und können sich einer logarithmischen Skala nähern, wobei sich der Schätzer überall Null nähert. Die Schätzer können parametrisiert werden, um eine niedrige Summe von quadratischen Fehlern bei negativen Signal-Rausch-Verhältnissen (SNRs) zu erreichen.

Bayesianische Schätzung

Der Maximum Likelihood (ML) -Schätzer in meiner ersten Antwort schnitt eher schlecht ab. Der ML-Schätzer kann auch als Bayes'scher Maximum-a-posteriori- Schätzer (MAP-Schätzer) verstanden werden, wenn eine falsche gleichmäßige vorherige Wahrscheinlichkeitsverteilung vorliegt. Falsch bedeutet hier, dass sich der Prior von null bis unendlich mit infinitesimaler Dichte erstreckt. Da die Dichte keine reelle Zahl ist, ist der Prior keine richtige Verteilung, aber er kann nach dem Bayes-Theorem immer noch eine richtige hintere Verteilung ergeben , die dann verwendet werden kann, um eine MAP- oder eine MMSE-Schätzung zu erhalten.

Der Satz von Bayes in Bezug auf Wahrscheinlichkeitsdichtefunktionen (PDFs) lautet:

$$\operatorname{PDF}(a\mid m) = \frac{\operatorname{PDF}(m\mid a)\,\operatorname{PDF}(a)}{\operatorname{PDF}(m)} = \frac{\operatorname{PDF}(m\mid a)\,\operatorname{PDF}(a)}{\int_0^\infty\operatorname{PDF}(m\mid a)\,\operatorname{PDF}(a)\,da}.\tag{1}$$

$\hat a_\text{MAP}$

$$\hat a_\text{MAP} = \underset{a}{\operatorname{arg\,max}}\operatorname{PDF}(a \mid m).\tag{2}$$

$\hat a_\text{MMSE}$

$$\hat a_\text{MMSE} = \underset{\hat a}{\operatorname{arg\,max}}\operatorname{E}[(a - \hat a)^2\mid m] = \operatorname{E}[a\mid m] = \int_0^\infty a \operatorname{PDF}(a\mid m)da.\tag{3}$$

Ein falscher einheitlicher Prior ist nicht der einzige skaleninvariante Prior. Alle vorherigen PDF-Dateien sind zufriedenstellend:

$$\operatorname{PDF(|X_k|)} \propto |X_k|^{\varepsilon-1},\tag{4}$$

$\varepsilon-1,$$\propto$$X_k$

Eine Familie von Schätzern

Es wird eine Familie von Schätzern mit folgenden Eigenschaften vorgestellt:

1. $X_k,$$|X_k|,$$\sigma$$\widehat{|X_k|}$
2. Minimaler Fehler der mittleren quadratischen transformierten Amplitude.
3. Unsachgemäßer gleichmäßiger Prior der transformierten Amplitude.

Wir werden normalisierte Notation verwenden:

$$\begin{array}{ll} a &= \frac{|X_k|}{\sigma}&\text{normalized clean amplitude,}\\ m &= \frac{|Y_k|}{\sigma}&\text{normalized noisy magnitude,}\\ 1 &= \left(\frac{\sigma}{\sigma}\right)^2&\text{normalized variance of noise,}\\ \mathrm{SNR} &= \left(\frac{|X_k|}{\sigma}\right)^2 = a^2&\text{signal-to-noise ratio ($10\log_{10}(\mathrm{SNR})$ dB),}\end{array}\tag{5}$$

$|X_k|$$|Y_k|$$Y_k$$X_k$$\sigma^2.$$|X_k|$

$$\operatorname{PDF}(a) \propto a^{\varepsilon - 1}.\tag{6}$$

$g(a)$$a.$

$$\operatorname{PDF}\big(g(a)\big) \propto 1.\tag{7}$$

Gl. 6 und 7 bestimmen zusammen die Familie möglicher Amplitudenumwandlungen. Sie hängen durch eine Änderung der Variablen zusammen :

$$\begin{array}{rrcl}&g'(a) \operatorname{PDF}\big(g(a)\big) &=& \operatorname{PDF}(a)\\ \displaystyle\Rightarrow&\quad g'(a) &\propto& a^{\varepsilon - 1}\\ \Rightarrow&g(a) &\propto& \displaystyle\int a^{\varepsilon - 1} da = \frac{a^\varepsilon}{\varepsilon} + c\\ \Rightarrow&g(a) &=& \displaystyle\frac{c_1a^\varepsilon}{\varepsilon} + c_0.\end{array}\tag{8}$$

We assume without proof that the choice of the constants $c_0$ and $c_1$ will not affect the amplitude estimate. For convenience we set:

$$\begin{array}{rc}&g(1) = 1\quad\text{and}\quad g'(1) = 1\\ \Rightarrow&c_0 = \displaystyle\frac{\varepsilon - 1}{\varepsilon}\quad\text{and}\quad c_1 = 1\\ \Rightarrow&g(a) = \displaystyle\frac{a^\varepsilon + \varepsilon - 1}{\varepsilon},\\ \end{array}\tag{9}$$

which has a special linear case:

$$g(a) = a\quad\text{if}\quad \varepsilon = 1,\tag{10}$$

and a limit:

$$\lim_{\varepsilon \to 0}g(a) = \log(a) + 1.\tag{11}$$

The transformation function can conveniently represent the linear amplitude scale (at $\varepsilon = 1$) and can approach a logarithmic amplitude scale (as $\varepsilon \to 0$). For positive $\varepsilon,$ the support of the PDF of transformed amplitude is:

$$\begin{eqnarray}&0 < a < \infty&\\ \Rightarrow\quad&\frac{\varepsilon - 1}{\varepsilon} < g(a) < \infty,&\end{eqnarray}\tag{12}$$

The inverse transformation function is:

$$g^{-1}\big(g(a)\big) = \big(\varepsilon g(a) - \varepsilon + 1\big)^{1/\varepsilon} = a.\tag{13}$$

The transformed estimate is then, using the law of the unconscious statistician:

$$\begin{gather}\hat a_\text{uni-MMSE-xform} = \underset{\hat a}{\operatorname{arg\,min}}\operatorname{E}\left[\big(g(a) - g(\hat a)\big)^2\mid m\right] = g^{-1}\big(\operatorname{E}[g(a) \mid m]\big)\\ = g^{-1}\left(\int_0^\infty g(a) \operatorname{PDF}(a \mid m)\,da\right)\\ = g^{-1}\left(\frac{\int_0^\infty g(a) f(a \mid m)da}{\int_0^\infty f(a \mid m)da}\right),\end{gather}\tag{14}$$

where $\operatorname{PDF}(a \mid b)$ is the posterior PDF and $f(a \mid m)$ is an unnormalized posterior PDF defined using Bayes' theorem (Eq. 1), the Rician $\operatorname{PDF}(m \mid a) = 2me^{-\left(m^2 + a^2\right)}I_0(2ma)$ from Eq. 3.2 of my ML estimator answer, and Eq. 6:

$$\begin{eqnarray}\operatorname{PDF}(a\mid m) &\propto& \operatorname{PDF}(m\mid a)\,\operatorname{PDF}(a)\\ &\propto&2me^{-\left(m^2 + a^2\right)}I_0(2ma)\times a^{\varepsilon - 1}\\ &\propto&e^{-a^2}I_0(2ma)\,a^{\varepsilon - 1} = f(a \mid m),\end{eqnarray}\tag{15}$$

from which $\operatorname{PDF}(m)$ was dropped from the Bayes' formula because it is constant over $a.$ Combining Eqs. 14, 9 & 15, solving the integrals in Mathematica, and simplifying, gives:

$$\begin{gather}\hat a_\text{uni-MMSE-xform}=g^{-1}\left(\frac{\int_0^\infty \frac{a^\varepsilon + \varepsilon - 1}{\varepsilon} \times e^{-a^2}I_0(2ma)\,a^{\varepsilon - 1}\,da}{\int_0^\infty e^{-a^2}I_0(2ma)\,a^{\varepsilon - 1}\,da}\right)\\ = \left(\varepsilon\frac{\frac{1}{2\varepsilon}\left(\Gamma(\varepsilon) L_{-\varepsilon}(m^2) + (\varepsilon-1) \Gamma(\varepsilon/2) L_{-\varepsilon/2}(m^2)\right)}{\frac{1}{2} \Gamma(\varepsilon/2) L_{-\varepsilon/2}(m^2)} - \varepsilon + 1\right)^{1/\varepsilon}\\ = \left(\frac{\Gamma(\varepsilon) L_{-\varepsilon}(m^2) + (\varepsilon-1) \Gamma(\varepsilon/2) L_{-\varepsilon/2}(m^2)}{\Gamma(\varepsilon/2) L_{-\varepsilon/2}(m^2)} - \varepsilon + 1\right)^{1/\varepsilon}\\ = \left(\frac{\Gamma(\varepsilon) L_{-\varepsilon}(m^2)}{\Gamma(\varepsilon/2) L_{-\varepsilon/2}(m^2)}\right)^{1/\varepsilon},\end{gather}\tag{16}$$

where $\Gamma$ is the gamma function and $L$ is the Laguerre function. The estimator collapses to zero everywhere as $\varepsilon \to 0,$ so it does not make sense to use negative $\varepsilon,$ which would emphasis small values of $a$ even further and give an improper posterior distribution. Some special cases are:

$$\hat a_\text{uni-MMSE-xform} = \sqrt{m^2 + 1},\quad\text{if }\varepsilon = 2,\tag{17}$$

$$\hat a_\text{uni-MMSE} = \hat a_\text{uni-MMSE-xform}= \frac{e^{m^2/2}}{\sqrt{\pi} I_0(m^2/2)},\quad\text{if }\varepsilon = 1,\tag{18}$$

approximated at large $m$ by (see calculation) a truncated Laurent series:

$$\hat a_\text{uni-MMSE} \approx m - \frac{1}{4m} - \frac{7}{32m^3} - \frac{59}{128m^5},\tag{19}$$

This asymptotic approximation has an absolute maximum amplitude error of less than $10^{-6}$ for $m > 7.7.$

The estimator curves are shown in Fig. 1.

Figure 1. Estimator $\hat a_\text{uni-MMSE-xform}$ as function of $m$ for different values of $\varepsilon,$ from top to bottom: blue: $\varepsilon = 2,$ which minimizes the mean square power error assuming an improper uniform prior of power, orange: $\varepsilon = 1,$ which minimizes the mean square amplitude error assuming an improper uniform prior of amplitude, green: $\varepsilon = \frac{1}{2},$ red: $\varepsilon = \frac{1}{4},$ and purple: $\varepsilon = \frac{1}{8}.$

At $m=0$ the curves are horizontal with value:

$$\hat a_\text{uni-MMSE-xform} = \frac{2^{1 - 1/\varepsilon} \bigg(\Gamma\Big(\frac{1 + \varepsilon}{2}\Big)\bigg)^{1/\varepsilon}}{\pi^{1/(2\varepsilon)}},\quad\text{if }m = 0.\tag{20}$$

At negative SNR, the uni-MMSE-xform estimator can be parameterized using low $\varepsilon$ to give a lower sum of square error compared to the clamped spectral power subtraction estimator, with a corresponding penalty at intermediate SNR values near 7 dB (Fig. 2).

Figure 2. Monte Carlo estimations with a sample size of $10^5,$ of: Solid: gain of sum of square error in estimating $|X_k|$ by $\widehat{|X_k|}$ as compared to estimating it with $|Y_k|,$ dashed: gain of sum of square error in estimating $|X_k|^2$ by $\widehat{|X_k|^2}$ as compared to estimating it with $|Y_k|^2,$ dotted: gain of sum of square error in estimating $X_k$ by $\widehat{|X_k|}e^{i\arg(Y_k)}$ as compared to estimating it with $Y_k.$ Blue: uni-MMSE-xform estimator with $\varepsilon = 1$ (top), $\varepsilon = \frac{1}{2}$ (middle), and $\varepsilon = \frac{1}{4},$ orange: clamped spectral power subtraction.

Python script for Fig. 1

This script extends the question's script A.

def est_a_uni_MMSE_xform(m, epsilon):
    m = mp.mpf(m)
    epsilon = mp.mpf(epsilon)
    if epsilon == 0:
        return mpf(0)
    elif epsilon == 1:
        return mp.exp(m**2/2)/(mp.sqrt(mp.pi)*mp.besseli(0, m**2/2))
    elif epsilon == 2:
        return mp.sqrt(m**2 + 1)
    else:
        return (mp.gamma(epsilon)*mp.laguerre(-epsilon, 0, m**2) / (mp.gamma(epsilon/2)*mp.laguerre(-epsilon/2, 0, m**2)))**(1/epsilon)

ms = np.arange(0, 6.0625, 0.0625)
est_as_uni_MMSE_xform = [[est_a_uni_MMSE_xform(m, 2) for m in ms], [est_a_uni_MMSE_xform(m, 1) for m in ms], [est_a_uni_MMSE_xform(m, 0.5) for m in ms], [est_a_uni_MMSE_xform(m, 0.25) for m in ms],  [est_a_uni_MMSE_xform(m, 0.125) for m in ms]]
plot_est(ms, est_as_uni_MMSE_xform)

Python script for Fig. 2

This script extends the question's script B. The function est_a_uni_MMSE_xform_fast may be numerically unstable.

from scipy import special

def est_a_uni_MMSE_fast(m):
    return 1/(np.sqrt(np.pi)*special.i0e(m**2/2))

def est_a_uni_MMSE_xform_fast(m, epsilon):
    if epsilon == 0:
        return 0
    elif epsilon == 1:
        return 1/(np.sqrt(np.pi)*special.i0e(m**2/2))
    elif epsilon == 2:
        return np.sqrt(m**2 + 1)
    else:
        return (special.gamma(epsilon)*special.eval_laguerre(-epsilon, m**2)/(special.gamma(epsilon/2)*special.eval_laguerre(-epsilon/2, m**2)))**(1/epsilon)

gains_SSE_a_uni_MMSE = [est_gain_SSE_a(est_a_uni_MMSE_fast, a, 10**5) for a in as_]
gains_SSE_a2_uni_MMSE = [est_gain_SSE_a2(est_a_uni_MMSE_fast, a, 10**5) for a in as_]
gains_SSE_complex_uni_MMSE = [est_gain_SSE_complex(est_a_uni_MMSE_fast, a, 10**5) for a in as_]
plot_gains_SSE(as_dB, [gains_SSE_a_uni_MMSE, gains_SSE_a_sub], [gains_SSE_a2_uni_MMSE, gains_SSE_a2_sub], [gains_SSE_complex_uni_MMSE, gains_SSE_complex_sub])

gains_SSE_a_uni_MMSE_xform_0e5 = [est_gain_SSE_a(lambda m: est_a_uni_MMSE_xform_fast(m, 0.5), a, 10**5) for a in as_]
gains_SSE_a2_uni_MMSE_xform_0e5 = [est_gain_SSE_a2(lambda m: est_a_uni_MMSE_xform_fast(m, 0.5), a, 10**5) for a in as_]
gains_SSE_complex_uni_MMSE_xform_0e5 = [est_gain_SSE_complex(lambda m: est_a_uni_MMSE_xform_fast(m, 0.5), a, 10**5) for a in as_]
plot_gains_SSE(as_dB, [gains_SSE_a_uni_MMSE_xform_0e5, gains_SSE_a_sub], [gains_SSE_a2_uni_MMSE_xform_0e5, gains_SSE_a2_sub], [gains_SSE_complex_uni_MMSE_xform_0e5, gains_SSE_complex_sub])

gains_SSE_a_uni_MMSE_xform_0e25 = [est_gain_SSE_a(lambda m: est_a_uni_MMSE_xform_fast(m, 0.25), a, 10**5) for a in as_]
gains_SSE_a2_uni_MMSE_xform_0e25 = [est_gain_SSE_a2(lambda m: est_a_uni_MMSE_xform_fast(m, 0.25), a, 10**5) for a in as_]
gains_SSE_complex_uni_MMSE_xform_0e25 = [est_gain_SSE_complex(lambda m: est_a_uni_MMSE_xform_fast(m, 0.25), a, 10**5) for a in as_]
plot_gains_SSE(as_dB, [gains_SSE_a_uni_MMSE_xform_0e25, gains_SSE_a_sub], [gains_SSE_a2_uni_MMSE_xform_0e25, gains_SSE_a2_sub], [gains_SSE_complex_uni_MMSE_xform_0e25, gains_SSE_complex_sub])

References

Lieve Lauwers, Kurt Barbe, Wendy Van Moer and Rik Pintelon, Analyzing Rice distributed functional magnetic resonance imaging data: A Bayesian approach, Meas. Sci. Technol. 21 (2010) 115804 (12pp) DOI: 10.1088/0957-0233/21/11/115804.

Minimale mittlere quadratische logarithmische Amplitudenfehlerschätzer der Amplitude

Diese Antwort enthält Schätzer, die den mittleren quadratischen logarithmischen Amplitudenfehler für eine Auswahl unpassender Prioritäten der sauberen Amplitude minimieren: gleichmäßig und linear.

Unsachgemäßer vorheriger Schätzer für den minimalen mittleren quadratischen logarithmischen Amplitudenfehler (uni-MMSE-log)

In der Literatur war eine nächste Entwicklung nach einem MMSE-Amplitudenschätzer ein MMSE-Log-Amplitudenschätzer, insbesondere der Schätzer von (Ephraim & Malah 1985, dank @MattL. Als Referenz), der einen Rician vor der sauberen Amplitude annimmt. In einem Versuch, den Schätzer zu verbessern$\hat a_\text{uni-MMSE}$ Hier wird ein Schätzer für den minimalen mittleren quadratischen logarithmischen Amplitudenfehler (uni-MMSE-log) für eine falsche Uniform vor der sauberen Amplitude abgeleitet.

Unter Verwendung der normalisierten Variablen meiner Antwort "Skaleninvariante minimale mittlere quadratische Fehler einheitliche vorherige Schätzer der transformierten Amplitude" Gl. (5) ist der Uni-MMSE-Log-Schätzer der sauberen Amplitude:

$$\hat a_\text{uni-MMSE-log}= \underset{\hat a}{\operatorname{arg\,min}}\operatorname{E}[(\log a - \log\hat a)^2\mid m] = \exp(\operatorname{E}[\log a \mid m]).\tag{1}$$

Verwenden Sie das Gesetz des unbewussten Statistikers und schreiben Sie dann die Schätzung in Form eines nicht normalisierten PDF$f(a\mid m) = \operatorname{PDF}(m \mid a),$und vereinfachen :

$$\begin{gather}\begin{aligned}\hat a_\text{uni-MMSE-log} &= \exp\left(\int_0^\infty \log(a) \operatorname{PDF}(a \mid m)\,da\right)\\ &= \exp\left(\frac{\int_0^\infty \log(a) f(a \mid m)da}{\int_0^\infty f(a \mid m)da}\right)\\ &= \exp\left(\frac{\int_0^\infty \log(a) \operatorname{PDF}(m \mid a)da}{\int_0^\infty \operatorname{PDF}(m \mid a)da}\right)\\ &= \exp\left(\frac{\int_0^\infty \log(a) 2me^{-\left(m^2 + a^2\right)}I_0(2ma)da}{\int_0^\infty 2me^{-\left(m^2 + a^2\right)}I_0(2ma)da}\right)\\ &= \exp\left(\frac{2me^{-m^2}\int_0^\infty \log(a) e^{-a^2}I_0(2ma)da}{m e^{-m^2} \sqrt{\pi} e^{m^2/2} I_0(m^2/2)}\right)\\ &= \exp\left(\frac{2\int_0^\infty \log(a) e^{-a^2}I_0(2ma)da}{\sqrt{\pi} e^{m^2/2} I_0(m^2/2)}\right)\end{aligned}\\ \begin{aligned}&= \exp\left(\frac{e^{m^2/2}\,I_0\left(\frac{m^2}{2}\right) \Psi\left(\frac{1}{2}\right) + m^2F^{1\,1\,2}_{2\,0\,1}\left(\begin{array}{c}3/2;\,1;\,1,1/2;\\2,\,2;;3/2;\end{array}\,m^2,m^2\right)}{2e^{m^2/2} I_0(m^2/2)}\right)\\ &= \exp\left(\frac{m^2F^{1\,1\,2}_{2\,0\,1}\left(\begin{array}{c}3/2;\,1;\,1,1/2;\\2,\,2;;3/2;\end{array}\,m^2,m^2\right)\Bigg)}{2e^{m^2/2} I_0(m^2/2)} - \frac{\gamma}{2} - \log 2\right),\end{aligned}\end{gather}\tag{2}$$

wo $\Psi$ist die Digammafunktion ,$\gamma$ist die Euler-Mascheroni-Konstante und$F^{1\,1\,2}_{2\,0\,1}$ist eine Kampé de Fériet (-ähnliche) Funktion . Diese spezielle Funktionsform des Schätzers kann in Pythons mpmath ausgewertet werden (siehe Skript am Ende der Antwort). Es gibt auch ein Formular mit Serien, für das keine speziellen Funktionen erforderlich sind:

$$\begin{gather}\begin{aligned}&= \exp\left(\frac{-L^{(1,0)}_{-1/2}\left(m^2\right)}{2e^{m^2/2}I_0(m^2/2)} + \frac{\Psi\left(\frac{1}{2}\right)}{2}\right)\\ &= \exp\left(\frac{\sum_{k=0}^\infty\left(\frac{(1/2)_k\,m^{2k}}{(1)_k\,k!}\sum_{n=1}^k \frac{1}{2n - 1}\right)}{e^{m^2/2}I_0(m^2/2)} + \frac{\Psi\left(\frac{1}{2}\right)}{2}\right)\\ &= \exp\left(\frac{\sum_{k=0}^\infty\left(\frac{(1/2)_k\,m^{2k}}{(1)_k\,k!}\sum_{n=1}^k \frac{1}{2n - 1}\right)}{\sum_{k=0}^\infty\frac{(1/2)_k\,m^{2k}}{(1)_k\,k!}} - \frac{\gamma}{2} - \log2\right),\end{aligned}\end{gather}\tag{3}$$

wo $L_n(x)$ ist Laguerres L-Funktion und hochgestellt $(1, 0)$ bezeichnet die Differenzierung in Bezug auf den tiefgestellten Parameter und $(x)_k$ist ein Pochhammer-Symbol mit Sonderfällen$(1)_k = k!$ und $(1/2)_k = (2k - 1)!!/2^k.$ Die Zähler- und Nennerreihen können bei zehn Termen abgeschnitten werden, um den Schätzer für niedrig zu erhalten $m.$Eine bessere Genauigkeit wird erzielt, wenn beide Reihen mit derselben Längenkürzung approximiert werden, verglichen mit der Verwendung einer exakten Sonderfunktion für die andere oder mit unterschiedlichen Längenkürzungen. Es ist schwierig, die Serie insgesamt zu bewerten$m$ weil die größten Begriffe herum erscheinen $k\approx m^2.$

Der ursprüngliche Ausdruck der Reihe von @ user150203 in Bezug auf das Zählerintegral gibt einen weiteren äquivalenten Ausdruck für den Schätzer:

$$\begin{eqnarray}&=& \exp\left(\frac{\sum_{k=0}^\infty \frac{m^{2k}}{k!} {k - \frac{1}{2} \choose k} \Psi\left(k + \frac{1}{2} \right)}{2 e^{m^2/2} I_0(m^2/2)}\right)\\ &=& \exp\left(\frac{\sum_{k=0}^\infty \frac{m^{2k}}{k!} {k - \frac{1}{2} \choose k} \Psi\left(k + \frac{1}{2} \right)}{2 \sum_{k=0}^\infty \frac{m^{2k}}{k!} {k - \frac{1}{2} \choose k}}\right),\end{eqnarray}\tag{4}$$

wo ${a\choose b}$bezeichnet einen Binomialkoeffizienten .

Die Kurve des Uni-MMSE-Log-Schätzers (Abb. 1, orangefarbene untere Kurve) ähnelt der des Uni-MMSE-Schätzers, jedoch mit einem niedrigeren Wert bei$m=0:$

$$\hat a_\text{uni-MMSE-log} = \frac{\sqrt{e^{-\gamma}}}{2} \approx 0.374653,\quad\text{if }m=0.\tag{5}$$

Unsachgemäßer vorheriger Schätzer des linearen minimalen quadratischen logarithmischen Amplitudenfehlers (lin-MMSE-log)

Ein verwandter Schätzer kann erhalten werden, wenn man die Grenze des Schätzers von (Ephraim & Malah 1985) bei unendlicher vorheriger Varianz der sauberen komplexen Variablen nimmt. Dann wird die Rayleigh- Prioritätswahrscheinlichkeitsdichtefunktion der sauberen Amplitude zu einer linearen Rampe, die bei einer Größe von Null Null ist und linear mit einer infinitesimalen Steigung ansteigt. Der resultierende Schätzer (Abb. 1, blaue obere Kurve) ist:

$$\begin{eqnarray}\hat a_\text{lin-MMSE-log} &=& \exp\left(\frac{1}{2}\int_{m^2}^\infty \frac{e^{-t}}{t} dt\right)m\\ &=& \exp\left(\frac{-\operatorname{Ei}\left(-m^2\right)}{2}\right)m\\ &=& \exp\left(\frac{Γ(0, m^2)}{2}\right)m,\end{eqnarray}\tag{6}$$ $$\lim_{m\to0^{+}}\hat a_\text{lin-MMSE-log} = e^{-\gamma/2}\tag{7} \approx 0.749306,$$

wo $\operatorname{Ei}(x)$ist das Exponentialintegral und$Γ(0, x)$ist die obere unvollständige Gammafunktion .

Abbildung 1. Schätzer für minimale mittlere quadratische logarithmische Amplitudenfehler: blau, oben: $\hat a_\text{lin-MMSE-log}$ mit einem falschen linearen Prior und Orange, niedriger: $\hat a_\text{uni-MMSE-log}$mit einer falschen Uniform vor. Geschätzte saubere Amplitude$\hat a$ als Funktion der verrauschten Größe $m$ mit additivem Rauschen der Einheitsvarianz.

Python-Skript für Abb. 1

Dieses Skript erweitert das Skript A der Frage. Die Funktion est_a_uni_MMSE_logist insgesamt numerisch instabil m.

def est_a_uni_MMSE_log(m):
    m = mp.mpf(m)
    return mp.exp(m**2*mp.hyper2d({'m+n':[1.5], 'n':[1], 'm':[1, 0.5]}, {'m+n':[2, 2], 'm':[1.5]}, m**2, m**2)/(2*mp.exp(m**2/2)*mp.besseli(0, m**2/2))-mp.euler/2-mp.log(2))

def est_a_lin_MMSE_log(m):
    m = mp.mpf(m)
    if m == 0:
        return mp.exp(-mp.euler/2)
    else:
        return mp.exp(-mp.ei(-m**2)/2)*m

ms = np.arange(0, 6.0625, 0.0625)
est_as_MMSE_log = [[est_a_lin_MMSE_log(m) for m in ms], [est_a_uni_MMSE_log(m) for m in ms]];    
plot_est(ms, est_as_MMSE_log)

Verweise

Y. Ephraim und D. Malah, Sprachverbesserung unter Verwendung eines logarithmischen Spektralamplitudenschätzers für minimale quadratische Fehler , IEEE Transactions on Acoustics Speech and Signal Processing , Mai 1985, DOI: 10.1109 / TASSP.1985.1164550 .