Il rumore bianco gaussiano a media zero reale, indipendente da un segnale pulito e di varianza nota viene aggiunto a producendo un segnale rumorosoTrasformata discreta di Fourier (DFT) del segnale rumoroso viene calcolata da:$x$$x$$y.$$Y$

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

Questo è solo per il contesto e definiremo la varianza del rumore nel dominio della frequenza, quindi la normalizzazione (o la sua mancanza) non è importante. Il rumore bianco gaussiano nel dominio del tempo è il rumore bianco gaussiano nel dominio della frequenza, vedi domanda: " Qual è la statistica della trasformata discreta di Fourier del rumore gaussiano bianco? ". Pertanto possiamo scrivere:

$$Y_k = X_k + Z_k,$$

dove e sono i DFT del segnale pulito e del rumore, e il del rumore che segue una distribuzione gaussiana complessa simmetrica circolare della varianza . Ciascuna parte reale e immaginaria di segue indipendentemente una distribuzione gaussiana della varianza . Definiamo il rapporto segnale-rumore (SNR) del bin come:$X$$Z$$Z_k$$\sigma^2$$Z_k$$\frac{1}{2}\sigma^2$$Y_k$

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

Un tentativo di ridurre il rumore viene quindi effettuato mediante sottrazione spettrale, per cui l'entità di ciascun contenitore viene ridotta indipendentemente mantenendo la fase originale (a meno che il valore del contenitore non vada a zero nella riduzione dell'ampiezza). La riduzione forma una stima del quadrato del valore assoluto di ogni bin del DFT del segnale pulito:$Y_k$$\widehat{|X_k|^2}$$|X_k|^2$

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

dove è la varianza nota del rumore in ciascun cestino DFT. Per semplicità, non stiamo prendendo in considerazione o per , che sono casi speciali per realeCon un SNR basso, la formulazione in (2) a volte potrebbe risultare inPossiamo rimuovere questo problema bloccando la stima a zero dal basso, ridefinendo:$\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}$$

Figura 1. Stime Monte Carlo con una dimensione del campione di di: Solido: guadagno della somma dell'errore quadrato nella stimadi rispetto alla stima con tratteggiato: guadagno della somma dell'errore quadrato nella stima di rispetto alla stima con punteggiato: guadagno della somma dell'errore quadrato nella stima di di rispetto alla stima conViene utilizzata la definizione di da (3).$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}$

Domanda: esiste un'altra stima dio che migliora su (2) e (3) senza fare affidamento sulla distribuzione di ?$|X_k|$$|X_k|^2$$Y_k$

Penso che il problema sia equivalente alla stima del quadrato del parametro di una distribuzione Rice (Fig. 2) con parametro noto data una singola osservazione.$\displaystyle{\nu_\mathrm{Rice}}$$\sigma_\mathrm{Rice} = \frac{\sqrt{2}}{2}\sigma,$

Figura 2. La distribuzione del riso è la distribuzione della distanza dall'origine da un punto che segue una distribuzione normale simmetrica circolare bivariata con un valore assoluto della media varianza e varianza dei componenti$R$$\nu_\mathrm{Rice},$$2\sigma_\mathrm{Rice}^2 = \sigma^2$$\sigma_\mathrm{Rice}^2 = \frac{1}{2}\sigma^2.$

Ho trovato della letteratura che sembra rilevante:

• Jan Sijbers, Arnold J. den Dekker, Paul Scheunders e Dirk Van Dyck, "Stima della massima verosimiglianza dei parametri di distribuzione Rician" , Transazioni IEEE sull'imaging medico (Volume: 17, Numero: 3, Giugno 1998) ( doi , pdf ).

Python script A per curve di stima

Questo script può essere esteso per tracciare curve di stima nelle risposte.

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

Script Python B per Fig. 1

Questo script può essere esteso per curve di guadagno di errore nelle risposte.

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)

Stimatore di massima verosimiglianza (ML)

Qui verrà derivato uno stimatore della massima probabilità della potenza del segnale pulito, ma non sembra migliorare le cose in termini di errore quadratico medio radice, per qualsiasi SNR, rispetto alla sottrazione di potenza spettrale.

introduzione

Introduciamo l'ampiezza normalizzata pulita e normalizzato magnitudo rumoroso normalizzato per la deviazione standard di rumore$a$$m$$\sigma:$

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

Lo stimatore in Eq. 3 della domanda fornisce una stima di as:$\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}$$

Stima della massima verosimiglianza

Per fare uno stimatore forse migliore di di Eq. 2, seguiamo la procedura di Sijbers et al. 1998. (vedi domanda) per costruire uno stimatore di massima verosimiglianza (ML)Fornisce il valore di che massimizza la probabilità del valore dato di$a$$\hat{a}_\mathrm{ML}.$$a$$m.$

Il PDF diè riciano con il parametroe parametro (da sostituire in seguito per maggiore chiarezza)$|Y_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}$$

dove è una funzione di Bessel modificata del primo tipo . Sostituzione e$I_\alpha$$|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}$$

e trasformando:

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

Il PDF riciano di parametrizzato da è indipendente dalla varianza del rumoreLo stimatore di massima verosimiglianza del parametro è il valore di che massimizza . È una soluzione di:$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}$$

La soluzione all'Eq. 4 ha la proprietà che:

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

Altrimenti deve essere risolto numericamente.

Figura 1. blu, in alto: lo stimatore di massima probabilità e arancione, in basso: lo stimatore di sottrazione spettrale di potenza della domanda di ampiezza pulita normalizzata , in funzione della magnitudine rumorosa normalizzata$\hat a_\mathrm{ML}$$\hat a$$a$$m.$

$\sigma\hat a_\mathrm{ML}$ è lo stimatore della massima verosimiglianza di e per invarianza funzionale della stima della massima verosimiglianza, è lo stimatore della verosimiglianza massima di$|X_k|,$$\sigma^2\hat a_\mathrm{ML}^2$$|X_k|^2.$

Serie empirica di Laurent dello stimatore ML

Ho provato a calcolare numericamente (vedi lo script più avanti) la serie Laurent di ma non sembra convergere per l'intervallo di necessario. Ecco un troncamento della serie Laurent per quanto l'ho calcolato:$\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}$$

Non sono riuscito a trovare le sequenze di numeri interi o denominatori nell'Enciclopedia in linea delle sequenze di numeri interi (OEIS). Solo per i primi cinque termini di potenza negativa, i coefficienti numeratori corrispondono a A027710 . Tuttavia, dopo aver inviato la sequenza calcolata ( ) a Superseeker OEIS , ho ottenuto questo nella risposta (da cui ho confermato i tre numeri suggeriti successivi con un calcolo esteso):$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]

Guadagno approssimativo tabulato e errore di stima

Una tabella interpolata linearmente (vedere gli script seguenti) contenente campioni distribuiti in modo non uniforme di fornisce un'approssimazione con un errore massimo di circa$124071$$\hat a_\mathrm{ML}^2-m^2$$6\times10^{-11}.$

Approssimazione dei minimi quadrati dello stimatore ML

È stata creata un'approssimazione dei minimi quadrati (con un peso extra a ) dei campioni della curva dello stimatore, in forma ispirata agli esperimenti della serie Laurent (vedere lo script di Octave più in basso). Il termine costante è stato modificato per rimuovere la possibilità di negativo at L'approssimazione è valida per e presenta un errore massimo di circa (Fig 3) in approssimazione$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

Figura 3. Errore dell'approssimazione dei minimi quadrati di$\hat a_\mathrm{ML}^2.$

Lo script sembra in grado di gestire l'aumento del numero di potenze negative di fornendo costantemente errori sempre più piccoli, con il numero di errori estremi in aumento, ma con un decadimento dell'errore massimo piuttosto lento. L'approssimazione è quasi equiripple, ma trarrebbe comunque beneficio dall'affinamento dello scambio di Remez .$m^2,$

Utilizzando l'approssimazione, sono state ottenute le seguenti curve di guadagno di errore previste:

Figura 2. Stime Monte Carlo con una dimensione del campione di di: Solido: guadagno della somma dell'errore quadrato nella stimadi rispetto alla stima con tratteggiato: guadagno della somma dell'errore quadrato nella stima di rispetto alla stima con punteggiato: guadagno della somma dell'errore quadrato nella stima di di rispetto alla stima conBlu: stimatore ML, arancione: sottrazione di potenza spettrale bloccata.$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.$

Sorprendentemente, lo stimatore ML è peggio della sottrazione di potenza spettrale bloccata in quasi tutti gli aspetti, tranne per essere leggermente migliore per la stima del segnale a SNR> circa 5 dB e la stima di ampiezza a SNR> circa 3 dB. A quei SNR, i due stimatori sono peggio del semplice uso del segnale rumoroso come stima.

Script Python A per Fig. 1

Questo script estende lo script della domanda A.

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)

Script Python per il calcolo numerico della serie Laurent

Questo script calcola numericamente i primi termini della serie Laurent diSi basa sullo script in questa risposta .$\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

Script Python per tabulazione dello stimatore ML

Questo script crea una tabella campionata in modo non uniforme delle coppie adatte per l'interpolazione lineare, fornendo approssimativamente l'errore di interpolazione lineare assoluta massima definita di approssimazione per l'intervalloLa dimensione della tabella viene automaticamente aumentata aggiungendo campioni alle parti difficili, fino a quando l'errore di picco è abbastanza piccolo. Se pari a più una potenza intera di poi tutti gli intervalli di campionamento sarà poteri di Al termine del tavolo ci sarà una transizione senza discontinuità ad una larga approssimazione$\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}.$Se è necessario, la mia ipotesi è che sia meglio interpolare la tabella così com'è e quindi fare la conversione$\hat{a}_\mathrm{ML}$$\hat{a}_\mathrm{ML} = \sqrt{\hat{a}_\mathrm{ML}^2}.$

Per l'uso in combinazione con lo script successivo, convogliare l'output > 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('];')

Script Python B per Fig. 2

Questo script estende lo script della domanda B.

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

Script di ottava per i minimi quadrati

Questo script di Octave (un adattamento di questa risposta ) fa almeno un quadrato di poteri di in . Gli esempi sono stati preparati dallo script Python un po 'sopra.$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}")

Script Python A2 per approssimazione usando polinomi di Chebyshev

Questo script estende lo script A e fornisce un'approssimazione alternativa dello stimatore ML usando i polinomi di Chebyshev. Il primo nodo di Chebyshev è a e il numero di polinomi di Chebyshev è tale che l'approssimazione non è negativa.$m=1$

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

Aggiornare:

Mi dispiace dover dire che i test mostrano che il seguente argomento sembra guastarsi sotto un forte rumore. Non è quello che mi aspettavo, quindi ho sicuramente imparato qualcosa di nuovo. I miei test precedenti erano stati tutti nella gamma SNR elevata poiché il mio obiettivo era quello di trovare soluzioni esatte nel caso silenzioso.

---

Olli,

Se il tuo obiettivo è trovare i parametri di un tono puro in un segnale rumoroso, avresti dovuto dirlo. Questo problema, ho molta esperienza e competenza in.

Dici che stai cercando l'ampiezza (e la fase ne deriva), quindi scommetto che stai allineando il tuo DFT per avere un numero intero di cicli. Questa è la peggior configurazione per questa situazione, dato che hai a che fare con il tuo segnale in un solo bin contro il rumore in quel singolo bin.

Come hai mostrato sopra, maggiore è il SNR, peggiore sarà il tuo trucco, al punto di essere dannoso o oltre. Bene, il tuo cestino di interesse sarà quello con il più alto SNR.

Quello che vuoi fare è allineare la cornice DFT su un intero più un mezzo ciclo. Questo diffonderà il tuo segnale su più bin possibili. Quindi puoi trovare la fase e l'ampiezza come descritto nel mio articolo di blog sull'argomento Calcolo di fase e ampiezza per un tono reale puro in un DFT: Metodo 1 .

In breve, trattate l'insieme di bidoni vicino al picco come uno spazio vettoriale complesso. Quindi conoscendo la frequenza, costruisci un insieme di vettori di base per il tuo segnale. I coefficienti dei vettori agiscono come un bidone virtuale che ti dirà l'ampiezza del segnale e la fase. Trovando il vettore che si adatta meglio tra più bin, la tecnica non consente al rumore in un dato bidone di essere troppo dominante e in qualche modo fornisce una "leva" su cui il rumore deve bilanciarsi. Gli effetti di riduzione del rumore sono simili a quando le variabili casuali vengono calcolate in media insieme.

Costruire i vettori di base significa prendere il DFT di un seno e un coseno alla tua frequenza. Ho una formula per il loro calcolo diretto che evita di dover fare una somma. L'articolo per questo è collegato dall'articolo sopra.

Sarei interessato a scoprire se la tua tecnica migliora i risultati di questo metodo. Sono abituato a lavorare con SNR superiori >> 1, quindi non ho mai testato realmente i livelli di rumore con cui hai a che fare.

Sinossi dell'approccio:

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

Perché il DFT è un operatore lineare:

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

In notazione vettoriale:

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

Siete semplicemente risolvendo per e usando l'algebra lineare standard per darvi una migliore vestibilità. Un vantaggio è che ottieni anche una stima di W. Pertanto, puoi provare un approccio "buttare il culo fuori", ed eliminare completamente il rumore stimato nel cestino peggiore e quindi ricalcolare. Risciacqua, ripeti. Oppure riduci il rumore in ogni cestino con un'altra formula. Se lo fai in modo proporzionale, i tuoi risultati rimarranno gli stessi di W ortogonale ad A e B. Ma una costante sottrazione lungo W, piuttosto che Z (come fa il tuo metodo) dovrebbe migliorare anche i risultati.$a$$b$

Normalmente, faccio i quattro bin attorno al picco, ma potresti voler estenderlo a 6 o addirittura 8. Ad un certo punto, più bin rende risultati peggiori poiché stai producendo più rumore del segnale.

Devi solo calcolare i bin di interesse DFT.

Un'interessante soluzione approssimativa del problema di stima della massima verosimiglianza (ML) si ottiene usando la formula asintotica

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

Utilizzando la notazione e le formule della risposta di Olli , la stima ML ottimale dell'ampiezza del segnale pulito normalizzato soddisfa

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

Usando e notando che , otteniamo l'approssimazione$(1)$$I_1(x)=I_0'(x)$

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

Questa approssimazione ha un errore relativo inferiore % per .$1$$x>4.5$

Inserendo in ottiene la soluzione approssimativa$(3)$$(2)$

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

Con e otteniamo$m=|Y_k|/\sigma$$a=|X_k|/\sigma$

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

che è semplicemente la media aritmetica dell'osservazione rumorosae la stima ottenuta dalla sottrazione di potenza spettrale.$|Y_k|$

---

MODIFICARE:

Sarebbe bello avere un'approssimazione come che funzioni su tutto l'intervallo . Un candidato per tale approssimazione è la famiglia di funzioni$(3)$$x\in[0,\infty)$

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

La scelta teoricamente corretta delle costanti è e , considerando le proprietà di attorno a e . Tuttavia, per un intervallo realistico di , è possibile ottenere una migliore approssimazione in quell'intervallo modificando un po 'quelle costanti.$c_1=4$$c_2=1$$f(x)$$x=0$$x\rightarrow\infty$$x$

Utilizzando l'approssimazione con e ottiene la seguente stima:$(6)$$c_1=4$$c_2=1$

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

o, equivalentemente,

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

---

Modifica di Olli:

Figura 1. (arancione) e le sue approssimazioni definite dall'Eq. 4 (blu) ed Eq. 7 (verde), in funzione diTutte le curve si avvicinano come (vedere la figura a destra per la grande ). avvicina asintoticamente alla sua serie troncata di Laurent come che dà il risultato curioso che nonostante le approssimazioni di avvicina asintoticamente come , il quadrato dell'Eq. 7 presenta un errore costante nell'approssimazione di come$\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$perché il termine costante 0 della sua serie Laurent differisce da della serie Laurent di (vedi la risposta dello stimatore ML di Olli) e la serie Laurent del quadrato di Eq. 4. Questo errore costante scompare nella stima di causa del fatto che$-\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.$

Script Python per Fig. 1

Questo script richiede lo script della domanda per l'importazione dei moduli e per la funzione di stampa plot_este la definizione della funzione est_a_MLdalla risposta ML di Olli.

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)

Stima precedente uniforme impropria errata di scala quadrata media invariante (MMSE) impropria di ampiezza trasformata

Questa risposta presenta uno stimatore invariante su scala familiare, parametrizzato da un singolo parametro che controlla sia la precedente distribuzione bayesiana dell'ampiezza sia la trasformazione dell'ampiezza in un'altra scala. Gli stimatori sono stimatori dell'errore quadrato medio minimo (MMSE) nella scala di ampiezza trasformata. Si presuppone un'uniforme uniforme impropria di ampiezza trasformata. Le trasformazioni disponibili includono una scala lineare (nessuna trasformazione) e possono avvicinarsi a una scala logaritmica per cui lo stimatore si avvicina allo zero ovunque. Gli stimatori possono essere parametrizzati per ottenere una bassa somma di errori quadrati con rapporti segnale-rumore negativi (SNR).

Stima bayesiana

Lo stimatore della massima verosimiglianza (ML) nella mia prima risposta ha funzionato piuttosto male. Lo stimatore ML può anche essere inteso come uno stimatore bayesiano massimo a posteriori (MAP) data una distribuzione di probabilità precedente uniforme impropria. Qui, improprio significa che il precedente si estende da zero a infinito con densità infinitesimale. Poiché la densità non è un numero reale, il precedente non è una distribuzione corretta, ma può comunque fornire una corretta distribuzione posteriore mediante il teorema di Bayes che può quindi essere utilizzato per ottenere una stima MAP o MMSE.

Il teorema di They Bayes in termini di funzioni di densità di probabilità (PDF) è:

$$\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}$$

Uno stimatore MAP $\hat a_\text{MAP}$ è l'argomento del PDF posteriore che lo massimizza:

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

Uno stimatore MMSE $\hat a_\text{MMSE}$ è la media posteriore:

$$\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}$$

Un priore uniforme improprio non è l'unico precedente invariante alla scala. Qualsiasi PDF precedente soddisfacente:

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

con vero esponente $\varepsilon-1,$ e $\propto$ significato: "è proporzionale a", è invariante alla scala nel senso che il prodotto di $X_k$e una costante positiva segue ancora la stessa distribuzione (vedi Lauwers et al. 2010 ).

Una famiglia di stimatori

Deve essere presentata una famiglia di stimatori, con queste proprietà:

1. Invarianza di scala: se il contenitore pulito complesso$X_k,$ o equivalentemente l'ampiezza pulita $|X_k|,$ e la deviazione standard del rumore $\sigma$ sono moltiplicati per la stessa costante positiva, quindi anche per l'ampiezza stimata $\widehat{|X_k|}$ viene moltiplicato per quella costante.
2. Errore di ampiezza trasformata quadrata media minima.
3. Priore uniforme improprio di ampiezza trasformata.

Useremo la notazione normalizzata:

$$\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}$$

dove $|X_k|$ è l'ampiezza pulita che desideriamo stimare dalla grandezza rumorosa $|Y_k|$ di valore bin $Y_k$ whicy è uguale alla somma del valore del cestino pulito $X_k$ più rumore di varianza gaussiana complesso a simmetria circolare $\sigma^2.$ Il precedente invariante di scala di $|X_k|$dato in Eq. 4 viene riportato alla notazione normalizzata come:

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

Permettere $g(a)$ essere una crescente funzione di trasformazione dell'ampiezza $a.$ Il priore uniforme improprio dell'ampiezza trasformata è indicato da:

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

Eq. 6 e 7 determinano insieme la famiglia delle possibili trasformazioni di ampiezza. Sono correlati da un cambiamento di variabili :

$$\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}$$

Assumiamo senza prove che la scelta delle costanti $c_0$ e $c_1$non influirà sulla stima dell'ampiezza. Per comodità impostiamo:

$$\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}$$

che ha un caso lineare speciale:

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

e un limite:

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

La funzione di trasformazione può rappresentare convenientemente la scala dell'ampiezza lineare (a $\varepsilon = 1$) e può avvicinarsi a una scala di ampiezza logaritmica (come $\varepsilon \to 0$). Per positivo$\varepsilon,$ il supporto del PDF di ampiezza trasformata è:

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

La funzione di trasformazione inversa è:

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

La stima trasformata è quindi, usando la legge dello statistico inconscio :

$$\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}$$

dove $\operatorname{PDF}(a \mid b)$ è il PDF posteriore e $f(a \mid m)$ è un PDF posteriore non normalizzato definito usando il teorema di Bayes (Eq. 1), il Riciano $\operatorname{PDF}(m \mid a) = 2me^{-\left(m^2 + a^2\right)}I_0(2ma)$dall'eq. 3.2 della mia risposta dello stimatore ML ed 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}$$

da cui $\operatorname{PDF}(m)$ è stato abbandonato dalla formula di Bayes perché è costante $a.$Combinazione di Eq. 14, 9 e 15, risolvendo gli integrali in Mathematica e semplificando, dà:

$$\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.

Minimum mean square log-amplitude error estimators of amplitude

This answer presents estimators that minimize the mean square log-amplitude error, for a selection of improper priors of the clean amplitude: uniform and linear.

Improper uniform prior minimum mean square log-amplitude error (uni-MMSE-log) estimator

In literature, a next development after a MMSE amplitude estimator has been a MMSE log-amplitude estimator, particularly the estimator of (Ephraim & Malah 1985, thanks to @MattL. for the reference) which assumes a Rician prior of the clean amplitude. In an attempt to improve upon the estimator $\hat a_\text{uni-MMSE}$ , here will be derived a minimum mean square log-amplitude error (uni-MMSE-log) estimator for an improper uniform prior of the clean amplitude.

Using the normalized variables of my answer "Scale-invariant minimum mean square error uniform prior estimators of transformed amplitude" Eq. (5), the uni-MMSE-log estimator of the clean amplitude is:

$$\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}$$

Using the law of the unconscious statistician, then writing the estimate in terms of an unnormalized PDF $f(a\mid m) = \operatorname{PDF}(m \mid a),$ and simplifying:

$$\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}$$

where $\Psi$ is the digamma function, $\gamma$ is the Euler–Mascheroni constant, and $F^{1\,1\,2}_{2\,0\,1}$ is a Kampé de Fériet (-like) function. This special function form of the estimator can be evaluated in Python's mpmath (see script at the end of the answer). There is also a form using series that requires no special functions:

$$\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}$$

where $L_n(x)$ is Laguerre's L function and superscript $(1, 0)$ denotes differentiating it with respect to the subscript parameter, and $(x)_k$ is a Pochhammer symbol with special cases $(1)_k = k!$ and $(1/2)_k = (2k - 1)!!/2^k.$ The numerator and denominator series can be truncated at tens of terms to obtain the estimator for low $m.$ Better accuracy is obtained by approximating both series using the same length truncation, compared to using an exact special function for the other, or different length truncations. It is difficult to evaluate the series at large $m$ because the largest terms appear around $k\approx m^2.$

@user150203's original expression of the series related to the numerator integral gives another equivalent expression for the estimator:

$$\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}$$

where ${a\choose b}$ denotes a binomial coefficient.

The curve of the uni-MMSE-log estimator (Fig. 1, orange lower curve) is similar to that of the uni-MMSE estimator, but with a lower value at $m=0:$

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

Improper linear prior minimum mean square log-amplitude error (lin-MMSE-log) estimator

A related estimator can be obtained if one takes the limit of the estimator of (Ephraim & Malah 1985) at infinite prior variance of the clean complex variable. Then, the Rayleigh prior probability density function of the clean amplitude becomes a linear ramp that is zero at zero magnitude and rises linearly with an infinitesimal slope. The resulting estimator (Fig. 1, blue upper curve) is:

$$\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,$$

where $\operatorname{Ei}(x)$ is the exponential integral, and $Γ(0, x)$ is the upper incomplete gamma function.

Figure 1. Minimum mean square log-amplitude error estimators: blue, upper: $\hat a_\text{lin-MMSE-log}$ with an improper linear prior and orange, lower: $\hat a_\text{uni-MMSE-log}$ with an improper uniform prior. Estimated clean amplitude $\hat a$ as function of noisy magnitude $m$ with unit-variance additive noise.

Python script for Fig. 1

This script extends the question's script A. The function est_a_uni_MMSE_log is numerically unstable at large 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)

References

Y. Ephraim and D. Malah, Speech enhancement using a minimum mean-square error log-spectral amplitude estimator, IEEE Transactions on Acoustics Speech and Signal Processing, May 1985, DOI: 10.1109/TASSP.1985.1164550.