O ruído branco gaussiano de média zero real, independente de um sinal limpo e da variação conhecida, é adicionado a produzindo um sinal barulhentoA transformada discreta de Fourier (DFT) do sinal ruidoso é calculada por:$x$$x$$y.$$Y$

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

Isso é apenas para o contexto, e definiremos a variação de ruído no domínio da frequência, para que a normalização (ou a falta dela) não seja importante. O ruído branco gaussiano no domínio do tempo é o ruído branco gaussiano no domínio da frequência. Veja a pergunta: " Quais são as estatísticas da transformada discreta de Fourier do ruído branco gaussiano? ". Portanto, podemos escrever:

$$Y_k = X_k + Z_k,$$

onde e são os do sinal e ruído limpos e o compartimento de ruído que segue uma distribuição gaussiana circularmente simétrica complexa e simétrica . Cada parte real e imaginária de segue independentemente uma distribuição gaussiana de variância . Definimos a relação sinal-ruído (SNR) da posição como:$X$$Z$$Z_k$$\sigma^2$$Z_k$$\frac{1}{2}\sigma^2$$Y_k$

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

Uma tentativa de reduzir o ruído é então feita por subtração espectral, em que a magnitude de cada compartimento é reduzida independentemente enquanto se mantém a fase original (a menos que o valor do compartimento seja zero na redução de magnitude). A redução forma uma estimativa do quadrado do valor absoluto de cada compartimento da DFT do sinal limpo:$Y_k$$\widehat{|X_k|^2}$$|X_k|^2$

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

onde é a variação conhecida de ruído em cada compartimento de DFT. Por simplicidade, não estamos considerando ou para pares , que são casos especiais para realEm um SNR baixo, a formulação em (2) às vezes pode resultar em negativoPodemos remover esse problema fixando a estimativa para zero a partir de baixo, redefinindo:$\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. Estimativas de Monte Carlo com um tamanho de amostra de de: Sólido: ganho da soma do erro quadrado na estimativapor em comparação com a estimativa com tracejado: ganho da soma do erro quadrado em estimar por em comparação com a estimativa com pontilhado: ganho da soma do erro quadrático na estimativa de por em comparação à estimativa comA definição de de (3) é usada.$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}$

Pergunta: Existe outra estimativa deou que melhora em (2) e (3) sem depender da distribuição de ?$|X_k|$$|X_k|^2$$Y_k$

Eu acho que o problema é equivalente a estimar o quadrado do parâmetro de uma distribuição Rice (Fig. 2) com o parâmetro conhecido dada uma única observação.$\displaystyle{\nu_\mathrm{Rice}}$$\sigma_\mathrm{Rice} = \frac{\sqrt{2}}{2}\sigma,$

Figura 2. Distribuição do arroz é a distribuição da distância à origem de um ponto que segue uma distribuição normal circularmente simétrica bivariada com um valor absoluto da média variância e variação do componente$R$$\nu_\mathrm{Rice},$$2\sigma_\mathrm{Rice}^2 = \sigma^2$$\sigma_\mathrm{Rice}^2 = \frac{1}{2}\sigma^2.$

Encontrei alguma literatura que parece relevante:

• Jan Sijbers, Arnold J. den Dekker, Paul Scheunders e Dirk Van Dyck, "Estimativa de máxima verossimilhança dos parâmetros de distribuição ricianos" , IEEE Transactions on Medical Imaging (Volume: 17, Edição: 3, Junho 1998) ( doi , pdf ).

Script Python A para curvas de estimador

Esse script pode ser estendido para plotar curvas do estimador nas respostas.

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 para a Fig. 1

Este script pode ser estendido para obter curvas de ganho de erro nas respostas.

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)

Estimador de máxima verossimilhança (ML)

Aqui será derivado um estimador de máxima probabilidade da potência do sinal limpo, mas não parece estar melhorando as coisas em termos de erro quadrático médio da raiz, para qualquer SNR, comparado à subtração de potência espectral.

Introdução

Vamos apresentar a amplitude limpa normalizada e a magnitude barulhenta normalizada normalizada pelo desvio padrão do ruído$a$$m$$\sigma:$

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

O estimador na Eq. 3 da questão fornece uma estimativa de como:$\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}$$

Estimador de máxima verossimilhança

Para fazer um estimador possivelmente melhor de que a Eq. 2, seguimos o procedimento de Sijbers et al. 1998. (veja a pergunta) para construir um estimador de máxima verossimilhança (ML)Dá o valor de que maximiza a probabilidade do valor dado de$a$$\hat{a}_\mathrm{ML}.$$a$$m.$

O PDF deé riciano com o parâmetroe parâmetro (para ser substituído posteriormente por clareza)$|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}$$

onde é uma função de Bessel modificada do primeiro tipo . Substituindo 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 transformando:

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

O PDF riciano de parametrizado por é independente da variação de ruídoO estimador de probabilidade máxima do parâmetro é o valor de que maximiza . É uma solução de:$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}$$

A solução para a Eq. 4 tem a propriedade de que:

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

Caso contrário, ele precisa ser resolvido numericamente.

Figura 1. azul, superior: o estimador de máxima verossimilhança e laranja, inferior: o estimador de subtração espectral de potência da questão de amplitude limpa normalizada , em função da magnitude barulhenta normalizada$\hat a_\mathrm{ML}$$\hat a$$a$$m.$

$\sigma\hat a_\mathrm{ML}$ é o estimador de probabilidade máxima de e por invariância funcional da estimativa de probabilidade máxima, é o estimador de probabilidade máxima de X_k$|X_k|,$$\sigma^2\hat a_\mathrm{ML}^2$$|X_k|^2.$

Série empírica de Laurent do estimador ML

Tentei calcular numericamente (veja o script mais abaixo) a série Laurent de mas parece não convergir para o intervalo de necessário. Aqui está um truncamento da série Laurent, tanto quanto eu calculei:$\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}$$

Não foi possível encontrar as seqüências inteiras de numerador ou denominador na Enciclopédia on-line de sequências inteiras (OEIS). Somente para os cinco primeiros termos de potência negativa, os coeficientes do numerador correspondem a A027710 . No entanto, depois de enviar a sequência computada ( ) para o OEIS Superseeker , obtive isso na resposta (da qual confirmei os próximos três números sugeridos por um cálculo estendido):$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]

Aproximação tabulada e ganho de erro de estimativa

Uma tabela interpolada linearmente (consulte scripts abaixo) contendo não uniformemente distribuídas de fornece uma aproximação com um erro máximo de cerca de$124071$$\hat a_\mathrm{ML}^2-m^2$$6\times10^{-11}.$

Aproximação dos mínimos quadrados do estimador ML

Uma aproximação de mínimos quadrados (com peso extra em ) das amostras da curva estimadora foi criada, de forma inspirada nos experimentos da série Laurent (veja o script Octave mais adiante). O termo constante foi alterado para remover a possibilidade de negativo em A aproximação é válida para e tem um erro máximo de cerca de (Fig 3) na aproximação de$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. Erro da aproximação dos mínimos quadrados de$\hat a_\mathrm{ML}^2.$

O script parece capaz de lidar com o aumento do número de potências negativas de dando consistentemente erros cada vez menores, com o número de erros extremos crescendo, mas com uma lenta e lenta deterioração máxima dos erros. A aproximação é quase dupla, mas ainda se beneficiaria um pouco do refinamento da troca de Remez .$m^2,$

Usando a aproximação, as seguintes curvas de ganho de erro esperadas foram obtidas:

Figura 2. Estimativas de Monte Carlo com um tamanho de amostra de de: Sólido: ganho da soma do erro quadrado na estimativapor em comparação com a estimativa com tracejado: ganho da soma do erro quadrado em estimar por em comparação com a estimativa com pontilhado: ganho da soma do erro quadrático na estimativa de por em comparação à estimativa comAzul: estimador ML, laranja: subtração de potência espectral presa.$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.$

Surpreendentemente, o estimador de ML é pior do que a subtração de potência espectral pinçada em quase todos os aspectos, exceto por ser marginalmente melhor para estimativa de sinal em SNR> cerca de 5 dB e estimativa de amplitude em SNR> cerca de 3 dB. Nesses SNR, os dois estimadores são piores do que apenas usar o sinal barulhento como estimativa.

Script Python A para a Fig. 1

Este script estende o script A. da pergunta

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 para cálculo numérico da série Laurent

Esse script calcula numericamente os primeiros termos da série Laurent deÉ baseado no script nesta resposta .$\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 para tabulação do estimador de ML

Este script cria uma tabela com amostragem desigual de pares adequados para interpolação linear, fornecendo aproximadamente o erro máximo absoluto definido de interpolação linear aproximada de para o intervaloO tamanho da tabela é aumentado automaticamente adicionando amostras às partes difíceis, até que o erro de pico seja pequeno o suficiente. Se é igual a , mais uma potência inteira de então todos os intervalos de amostragem será potências de No final da tabela haverá uma transição sem descontinuidade a uma larga aproximação$\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 for necessário, meu palpite é que é melhor interpolar a tabela como está e fazer a conversão$\hat{a}_\mathrm{ML}$$\hat{a}_\mathrm{ML} = \sqrt{\hat{a}_\mathrm{ML}^2}.$

Para uso em conjunto com o próximo script, canalize a saída > 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 para a Fig. 2

Esse script estende o script B. da pergunta

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 de oitava para mínimos quadrados

Este script Oitava (uma adaptação desta resposta ) ajusta os mínimos quadrados de poderes de em . As amostras foram preparadas pelo script Python um pouco acima.$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 para aproximação usando polinômios de Chebyshev

Esse script estende o script A e fornece uma aproximação alternativa do estimador de ML usando polinômios de Chebyshev. O primeiro nó Chebyshev está em e o número de polinômios de Chebyshev é tal que a aproximação é não-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

Atualizar:

Lamento dizer que o teste mostra que o seguinte argumento parece ser quebrado sob um ruído intenso. Não era o que eu esperava, então definitivamente aprendi algo novo. Todos os meus testes anteriores estavam na faixa alta de SNR, pois meu foco estava em encontrar soluções exatas no caso silencioso.

---

Olli,

Se seu objetivo é encontrar os parâmetros de um tom puro em um sinal barulhento, você deveria ter dito isso. Nesta edição, tenho muita experiência e conhecimento.

Você diz que está procurando a amplitude (e a fase vem com ela), por isso aposto que está alinhando sua DFT para ter um número inteiro de ciclos. Essa é a pior configuração para essa situação, pois você lida com o sinal em apenas uma única posição contra o ruído nessa única posição.

Como você mostrou acima, quanto maior o SNR, pior será o seu truque, a ponto de prejudicial ou além. Bem, seu escopo de interesse será aquele com o maior SNR.

O que você quer fazer é alinhar seu quadro DFT em um todo mais meio ciclo. Isso espalhará seu sinal pelo maior número possível de caixas. Em seguida, você pode encontrar a fase e a amplitude, conforme descrito no artigo do meu blog, no tópico Cálculo de fase e amplitude para um tom real puro em uma DFT: Método 1 .

Em resumo, você trata o conjunto de caixas perto do pico como um espaço vetorial complexo. Então, conhecendo a frequência, você constrói um conjunto de vetores básicos para o seu sinal. Os coeficientes dos vetores atuam como um compartimento virtual que informa a amplitude do sinal e a fase. Ao encontrar o vetor de melhor ajuste em vários compartimentos, a técnica não permite que o ruído em um determinado compartimento seja muito dominante e meio que fornece uma "alavanca" que o ruído precisa equilibrar. Os efeitos de redução de ruído são semelhantes a quando variáveis ​​aleatórias são calculadas em média juntas.

Construir os vetores base significa tomar a DFT de um seno e cosseno na sua frequência. Eu tenho uma fórmula para o cálculo direto que ignora ter que fazer uma soma. O artigo para isso está vinculado no artigo acima.

Eu estaria interessado em descobrir se sua técnica melhora os resultados desse método. Estou acostumado a trabalhar com SNR >> 1 mais alto, então nunca testei realmente nos níveis de ruído com os quais você está lidando.

Sinopse da abordagem:

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

Como o DFT é um operador linear:

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

Em notação vetorial:

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

Você simplesmente está resolvendo para e usando álgebra linear padrão para lhe dar um melhor ajuste. Um bônus é que você também obtém uma estimativa de W. Portanto, você pode tentar uma abordagem "jogar fora o bumbum" e eliminar completamente o ruído estimado na bandeja com pior ajuste e depois recalcular. Enxágüe, repita. Ou reduza o ruído em cada caixa por outra fórmula. Se você fizer isso proporcionalmente, seus resultados permanecerão os mesmos que W é ortogonal a A e B. Mas uma subtração constante ao longo de W, em vez de Z (como o método faz) também deve melhorar os resultados.$a$$b$

Normalmente, eu faço os quatro compartimentos em torno do pico, mas você pode estender para 6 ou até 8. Em algum momento, mais compartimentos produzem resultados piores à medida que você gera mais ruído do que sinal.

Você só precisa calcular os depósitos de DFT de interesse.

Uma solução aproximada interessante do problema de estimativa de máxima verossimilhança (ML) é obtida usando a fórmula assintótica

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

Usando a notação e as fórmulas da resposta de Olli , a estimativa ótima de ML da amplitude normalizada do sinal limpo satisfaz

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

Usando e observando que , obtemos a aproximação$(1)$$I_1(x)=I_0'(x)$

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

Essa aproximação tem um erro relativo menor que % para .$1$$x>4.5$

A conexão em fornece a solução aproximada$(3)$$(2)$

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

Com e obtemos$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}$$

que é simplesmente a média aritmética da observação barulhentae a estimativa obtida da subtração de potência espectral.$|Y_k|$

---

EDITAR:

Seria bom ter uma aproximação como que funcione em todo o intervalo . Um candidato para essa aproximação é a família de funções$(3)$$x\in[0,\infty)$

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

A escolha teoricamente correcta das constantes é e , considerando as propriedades de em torno de e . No entanto, para um intervalo realista de , uma melhor aproximação nesse intervalo pode ser possível ajustando um pouco essas constantes.$c_1=4$$c_2=1$$f(x)$$x=0$$x\rightarrow\infty$$x$

Usando a aproximação com e resulta na seguinte estimativa:$(6)$$c_1=4$$c_2=1$

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

ou equivalente,

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

---

Edição de Olli:

Figura 1. (laranja) e suas aproximações definidas pela Eq. 4 (azul) e Eq. 7 (verde), em função deTodas as curvas se aproximam de como (veja a figura à direita para grande ). aproxima assintoticamente da série Laurent truncada como que dá o resultado curioso de que, embora as aproximações de aproxima-se assintoticamente como , o quadrado da Eq. 7 tem erro constante ao aproximar como$\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$porque o termo constante 0 de sua série Laurent difere de da série Laurent de (consulte a resposta do estimador de ML de Olli) e da série Laurent do quadrado de Eq. 4. Este erro constante desaparece na estimativa de devido ao fato de que$-\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 para a Fig. 1

Esse script requer o script da pergunta para importação de módulos e para a função de plotagem plot_est, e a definição da função da est_a_MLresposta ML de 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)

Estimativas anteriores uniformes impróprias uniformes inadequadas antes do erro quadrático médio invariante na escala (MMSE)

Esta resposta apresenta estimadores invariantes em escala de família, parametrizados por um único parâmetro que controla a distribuição Bayesiana anterior de amplitude e a transformação de amplitude em outra escala. Os estimadores são estimadores de erro quadrático médio mínimo (MEEM) na escala de amplitude transformada. Um uniforme inadequado antes da amplitude transformada é assumido. As transformações disponíveis incluem uma escala linear (sem transformação) e podem se aproximar de uma escala logarítmica, na qual o estimador se aproxima de zero em qualquer lugar. Os estimadores podem ser parametrizados para obter uma soma baixa de erro quadrado em relações sinal-ruído negativas (SNRs).

Estimação bayesiana

O estimador de máxima verossimilhança (ML) na minha primeira resposta teve um desempenho bastante fraco. O estimador de ML também pode ser entendido como um estimador Bayesiano de máximo a posteriori (PAM), dada uma distribuição de probabilidade anterior inadequada e uniforme. Aqui, impróprio significa que o anterior se estende de zero ao infinito com densidade infinitesimal. Como a densidade não é um número real, o prioritário não é uma distribuição adequada, mas ainda pode fornecer uma distribuição posterior adequada pelo teorema de Bayes, que pode ser usada para obter uma estimativa de MAP ou MMSE.

O teorema de Bayes em termos de funções de densidade de probabilidade (PDFs) é:

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

Um estimador de MAP é o argumento do PDF posterior que o maximiza:$\hat a_\text{MAP}$

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

Um estimador MMSE é a média posterior:$\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}$$

Um anterior uniforme inadequado não é o único anterior invariante na escala. Qualquer PDF anterior que satisfaça:

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

com expoente real e significado: "é proporcional a", é invariante em escala no sentido de que o produto de e uma constante positiva ainda seguem a mesma distribuição (ver Lauwers et al. 2010 ).$\varepsilon-1,$$\propto$$X_k$

Uma família de estimadores

Uma família de estimadores deve ser apresentada, com as seguintes propriedades:

1. Invariância de escala: se o compartimento limpo complexo ou equivalentemente a amplitude limpa e o desvio padrão do ruído forem multiplicados pela mesma constante positiva, também a amplitude estimada será multiplicada por essa constante.$X_k,$$|X_k|,$$\sigma$$\widehat{|X_k|}$
2. Erro mínimo de amplitude transformada do quadrado médio.
3. Uniforme inadequado antes da amplitude transformada.

Usaremos notação normalizada:

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

ondeé a amplitude limpa que queremos estimar a partir da magnitude barulhentado valor do compartimento whicy é igual à soma do valor do compartimento limpo mais o ruído gaussiano de variância complexo circularmente simétricoO invariante de escala anterior dedado na Eq. 4 é transferido para a notação normalizada como:$|X_k|$$|Y_k|$$Y_k$$X_k$$\sigma^2.$$|X_k|$

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

Seja uma função crescente de transformação da amplitudeO uniforme inadequado antes da amplitude transformada é indicado por:$g(a)$$a.$

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

Eqs. 6 e 7 juntos determinam a família de possíveis transformações de amplitude. Eles são relacionados por uma mudança de variáveis :

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

Assumimos sem prova que a escolha das constantes e não afetará a estimativa de amplitude. Por conveniência, definimos:$c_0$$c_1$

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

que tem um caso linear especial:

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

e um limite:

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

A função de transformação pode representar convenientemente a escala de amplitude linear (em ) e pode se aproximar de uma escala de amplitude logarítmica (como ). Para positivo o suporte do PDF de amplitude transformada é:$\varepsilon = 1$$\varepsilon \to 0$$\varepsilon,$

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

A função de transformação inversa é:

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

A estimativa transformada é então, usando a lei do estatístico inconsciente :

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

onde é o PDF posterior é um PDF posterior não normalizado definido usando o teorema de Bayes (Eq. 1), o Rician da Eq. 3,2 da minha resposta do estimador de ML e Eq. 6:$\operatorname{PDF}(a \mid b)$$f(a \mid m)$$\operatorname{PDF}(m \mid a) = 2me^{-\left(m^2 + a^2\right)}I_0(2ma)$

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

do qual foi retirado da fórmula de Bayes porque é constante ao longo deCombinando Eqs. 14, 9 e 15, resolvendo as integrais no Mathematica e simplificando, fornece:$\operatorname{PDF}(m)$$a.$

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

onde é a função gama e é a função Laguerre . O estimador cai para zero em todos os lugares como por isso não faz sentido para uso negativo que ênfase valores pequenos de ainda mais e dar uma distribuição posterior inadequada. Alguns casos especiais são:$\Gamma$$L$$\varepsilon \to 0,$$\varepsilon,$$a$

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

aproximado em grande por ( ver cálculo ) uma série Laurent truncada:$m$

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

Essa aproximação assintótica tem um erro de amplitude máxima absoluta inferior a para$10^{-6}$$m > 7.7.$

As curvas do estimador são mostradas na Fig. 1.

Figura 1. Estimador como função de para diferentes valores de de cima para baixo: azul: que minimiza o erro de potência quadrático médio assumindo um uniforme inadequado antes da energia, laranja: que minimiza o erro médio de amplitude quadrada assumindo um uniforme inadequado antes da amplitude, verde: vermelho: e roxo:$\hat a_\text{uni-MMSE-xform}$$m$$\varepsilon,$$\varepsilon = 2,$$\varepsilon = 1,$$\varepsilon = \frac{1}{2},$$\varepsilon = \frac{1}{4},$$\varepsilon = \frac{1}{8}.$

Em as curvas são horizontais com valor:$m=0$

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

No SNR negativo, o estimador uni-MMSE-xform pode ser parametrizado usando low para fornecer uma soma menor de erro quadrado em comparação com o estimador de subtração de potência espectral pinçada, com uma penalidade correspondente em valores SNR intermediários próximos a 7 dB (Fig. 2 )$\varepsilon$

Figura 2. Estimativas de Monte Carlo com um tamanho de amostra de de: Sólido: ganho da soma do erro quadrado na estimativapor em comparação com a estimativa com tracejado: ganho da soma do erro quadrado em estimar por em comparação com a estimativa com pontilhado: ganho da soma do erro quadrático na estimativa de por em comparação à estimativa comAzul: estimador uni-MMSE-xform com (em cima), (meio) e$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.$$\varepsilon = 1$$\varepsilon = \frac{1}{2}$$\varepsilon = \frac{1}{4},$ laranja: subtração de potência espectral fixa.

Script Python para a Fig. 1

Este script estende o script A. da pergunta

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)

Script Python para a Fig. 2

Esse script estende o script B. da pergunta. A função est_a_uni_MMSE_xform_fastpode ser numericamente instável.

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

Referências

Lieve Lauwers, Kurt Barbe, Wendy Van Moer e Rik Pintelon, Analyzing Rice, distribuíram dados funcionais de ressonância magnética: Uma abordagem bayesiana , Meas. Sci. Technol. 21 (2010) 115804 (12pp) DOI: 10.1088 / 0957-0233 / 21/11/115804 .

Estimadores de erro mínimos quadrados médios da amplitude logarítmica

Esta resposta apresenta estimadores que minimizam o erro quadrático médio da amplitude logarítmica, para uma seleção de anteriores impróprios da amplitude limpa: uniforme e linear.

Estimador uniforme anterior mínimo mínimo incorreto do quadrado da amplitude logarítmica (uni-MMSE-log)

Na literatura, um próximo desenvolvimento após um estimador de amplitude MMSE foi um estimador de amplitude logarítmica do MMSE, particularmente o estimador de (Ephraim & Malah 1985, graças a @MattL. Para a referência), que assume um prior riciano da amplitude limpa. Na tentativa de melhorar o estimador , será derivado aqui um estimador de erro quadrático médio mínimo de amplitude de log (uni-MMSE-log) para um uniforme impróprio antes da amplitude limpa.$\hat a_\text{uni-MMSE}$

Usando as variáveis ​​normalizadas da minha resposta "Erro mínimo médio quadrático invariante na escala uniforme estimadores anteriores da amplitude transformada" Eq. (5), o estimador uni-MMSE-log da amplitude limpa é:

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

Usando a lei do estatístico inconsciente , escrevendo a estimativa em termos de um PDF não normalizado e simplificando :$f(a\mid m) = \operatorname{PDF}(m \mid a),$

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

onde é a função digamma , é a constante de Euler – Mascheroni e é uma função de Kampé de Fériet (semelhante a) . Essa forma de função especial do estimador pode ser avaliada no mpmath do Python (consulte o script no final da resposta). Há também um formulário usando séries que não requer funções especiais:$\Psi$$\gamma$$F^{1\,1\,2}_{2\,0\,1}$

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

onde é a função L de Laguerre e sobrescrito indica diferenciação em relação ao parâmetro subscrito e é um símbolo de Pochhammer com casos especiaiseAs séries de numeradores e denominadores podem ser truncadas em dezenas de termos para obter o estimador para baixoÉ obtida uma melhor precisão aproximando as duas séries usando o mesmo truncamento de comprimento, em comparação com o uso de uma função especial exata para o outro ou truncamentos de comprimento diferentes. É difícil avaliar a série em geral porque os termos maiores aparecem em torno de$L_n(x)$$(1, 0)$$(x)_k$$(1)_k = k!$$(1/2)_k = (2k - 1)!!/2^k.$$m.$$m$$k\approx m^2.$

A expressão original de @ user150203 da série relacionada à integral do numerador fornece outra expressão equivalente para o estimador:

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

onde indica um coeficiente binomial .${a\choose b}$

A curva do estimador uni-MMSE-log (Fig. 1, curva inferior laranja) é semelhante à do estimador uni-MMSE, mas com um valor mais baixo em$m=0:$

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

Estimador incorreto linear anterior mínimo mínimo de erro de amplitude logarítmica quadrado (lin-MMSE-log)

Um estimador relacionado pode ser obtido se considerarmos o limite do estimador de (Ephraim & Malah 1985) com variação prévia infinita da variável complexa limpa. Então, a função de densidade de probabilidade anterior de Rayleigh da amplitude limpa torna-se uma rampa linear que é zero na magnitude zero e aumenta linearmente com uma inclinação infinitesimal. O estimador resultante (Fig. 1, curva superior azul) é:

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

onde é a integral exponencial e é a função gama incompleta superior .$\operatorname{Ei}(x)$$Γ(0, x)$

Figura 1. Estimadores de erro quadrático médio mínimo de amplitude de log quadrado: azul, superior: com um anterior linear e laranja incorretos, inferior: com um uniforme impróprio antes. A amplitude limpa estimada é função de magnitude ruidosa com ruído aditivo de variação de unidade.$\hat a_\text{lin-MMSE-log}$$\hat a_\text{uni-MMSE-log}$$\hat a$$m$

Script Python para a Fig. 1

Esse script estende o script A. da pergunta. A função est_a_uni_MMSE_logé numericamente instável em geral 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)

Referências

Y. Ephraim e D. Malah, Aperfeiçoamento da fala usando um estimador de amplitude espectral logarítmica de erro quadrático médio mínimo , IEEE Transactions on Acoustics Speech and Signal Processing , maio de 1985, DOI: 10.1109 / TASSP.1985.1164550 .