Gerçek zamanlı ortalama ve standart sapmanın belirlenmesi

Gerçek zamanlı bir uygulama için bir sinyalin ortalama ve standart sapmasını bulmak için ideal yol ne olurdu. Bir sinyal belirli bir süre için ortalamanın 3 standart sapmasından fazla olduğunda bir denetleyiciyi tetikleyebilmek istiyorum.

Özel bir DSP'nin bunu kolayca yapacağını farz ediyorum, ancak çok karmaşık bir şey gerektirmeyen herhangi bir "kısayol" var mı?

Jason R'ın cevabında, Knuth'un "Bilgisayar Programlama Sanatı" adlı kitabında tartışılan bir kusur var. 2. Sorun, ortalamanın küçük bir kısmı olan standart bir sapmanız varsa ortaya çıkar: E (x ^ 2) - (E (x) ^ 2) 'nin hesaplanması, hassas hassasiyetten kayan nokta yuvarlama hatalarına maruz kalır.

Bunu bir Python betiğinde de deneyebilirsiniz:

ofs = 1e9
A = [ofs+x for x in [1,-1,2,3,0,4.02,5]] 
A2 = [x*x for x in A]
(sum(A2)/len(A))-(sum(A)/len(A))**2

Matematik, sonucun negatif olamayacağını öngördüğü için, açıkça hesaplamalı olarak geçerli olmayan bir cevap olarak -128.0 elde ediyorum.

Knuth, koşu ortalamasını ve bunun gibi bir şeye giden standart sapmayı hesaplamak için (mucidin adını hatırlamıyorum) bir yaklaşıma işaret ediyor:

 initialize:
    m = 0;
    S = 0;
    n = 0;

 for each incoming sample x:
    prev_mean = m;
    n = n + 1;
    m = m + (x-m)/n;
    S = S + (x-m)*(x-prev_mean);

ve sonra her adımdan sonra, değeri mortalamadır ve standart sapma , en sevdiğiniz standart sapma tanımına bağlı olarak sqrt(S/n)veya bu şekilde hesaplanabilir sqrt(S/n-1).

Yukarıda yazdığım denklem Knuth'dakiden biraz farklı, ancak hesaplamalı olarak eşdeğer.

Birkaç dakikam olduğunda, yukarıdaki formülü Python'da kodlayacağım ve negatif olmayan bir cevap alacağınızı göstereceğim (umarım doğru değere yakındır).

güncelleme: işte burada.

test1.py:

import math

def stats(x):
  n = 0
  S = 0.0
  m = 0.0
  for x_i in x:
    n = n + 1
    m_prev = m
    m = m + (x_i - m) / n
    S = S + (x_i - m) * (x_i - m_prev)
  return {'mean': m, 'variance': S/n}

def naive_stats(x):
  S1 = sum(x)
  n = len(x)
  S2 = sum([x_i**2 for x_i in x])
  return {'mean': S1/n, 'variance': (S2/n - (S1/n)**2) }

x1 = [1,-1,2,3,0,4.02,5] 
x2 = [x+1e9 for x in x1]

print "naive_stats:"
print naive_stats(x1)
print naive_stats(x2)

print "stats:"
print stats(x1)
print stats(x2)

sonuç:

naive_stats:
{'variance': 4.0114775510204073, 'mean': 2.0028571428571427}
{'variance': -128.0, 'mean': 1000000002.0028572}
stats:
{'variance': 4.0114775510204073, 'mean': 2.0028571428571431}
{'variance': 4.0114775868357446, 'mean': 1000000002.0028571}

Hala bir yuvarlama hatası olduğunu not edersiniz, ancak fena değil, oysa naive_statssadece kusar.

düzenleme: Sadece Belisarius'un Knuth algoritmasından bahseden Vikipedi'ye atıfta bulunan yorumunu fark ettim .

Gerçek zamanlı bir uygulama için bir sinyalin ortalama ve standart sapmasını bulmak için ideal yol ne olurdu. Bir sinyal belirli bir süre için ortalamanın 3 standart sapmasından fazla olduğunda bir denetleyiciyi tetikleyebilmek istiyorum.

Bunun gibi durumlarda doğru yaklaşım tipik olarak üssel olarak ağırlıklandırılmış bir koşu ortalamasını ve standart sapmayı hesaplamaktır. Üstel ağırlıklı ortalamada, ortalama ve varyans tahminleri, en son numuneye doğru önyargılıdır , son saniye boyunca$\tau$ ortalama ve varyans tahminlerini size verir , bu muhtemelen tüm numunelerdeki normal aritmetik ortalamadan ziyade istediğiniz şeydir. gördüğüm.

Frekans alanında, "üssel olarak ağırlıklı bir koşu ortalaması" sadece gerçek bir kutuptur. Zaman alanında uygulamak kolaydır.

Zaman alanı uygulaması

Sinyal karesinin ortalaması ve ortalaması için geçerli tahminler olsun meanve olsun meansq. Her döngüde, bu tahminleri yeni örnekle güncelleyin x:

% update the estimate of the mean and the mean square:
mean = (1-a)*mean + a*x
meansq = (1-a)*meansq + a*(x^2)

% calculate the estimate of the variance:
var = meansq - mean^2;

% and, if you want standard deviation:
std = sqrt(var);

Burada , koşu ortalamasının efektif uzunluğunu belirleyen bir sabittir. Nasıl seçilir bir "analiz" aşağıda açıklanmıştır.$0 < a < 1$$a$

Zorunlu bir program olarak yukarıda belirtilenler ayrıca bir sinyal akış diyagramı olarak da gösterilebilir:

analiz

$y_i = a x_i + (1-a) y_{i-1}$$x_i$$i$$y_i$$z$

IIR filtrelerini kendi bloklarında yoğunlaştırmak için, şema şimdi şöyle görünür:

$z = e^{s T}$$T$$f_s = 1/T$$1-(1-a)e^{-sT}=0$$s = \frac{1}{T} \log (1-a)$

$a$

Referanslar

• Simulink diyagramı kaynağı https://gist.github.com/1942771 adresinden indirilebilir.

Daha önce bir gömülü işleme uygulamasında daha önce kullandığım bir yöntem, ilgilenilen sinyalin toplamının ve toplamının toplamının biriktiricilerini muhafaza etmektir:

$i$$i$

veya kullanabilirsiniz:

Tercih ettiğiniz standart sapma tahmin yöntemine bağlı olarak . Bu denklemler varyansın tanımına dayanmaktadır :

Bunları geçmişte başarıyla kullandım (her ne kadar sadece standart sapma değil, sapma tahminiyle ilgileniyor olmama rağmen), ancak toplanacaksa akümülatörleri tutmak için kullandığınız sayısal türler konusunda dikkatli olmanız gerekir. uzun bir süre; taşması istemiyorsun.

Düzenleme: Taşma ile ilgili yukarıdaki açıklamaya ek olarak, bunun kayan nokta aritmetik olarak uygulandığında sayısal olarak güçlü bir algoritma olmadığı, tahmin edilen istatistiklerde potansiyel olarak büyük hatalara neden olduğu belirtilmelidir. Bu durumda daha iyi bir yaklaşım için Jason S'nin cevabına bakınız.

Yukarıdaki tercih edilen cevaba benzer (Jason S.) ve ayrıca Knut'tan alınan formülden de türetilmiştir (Cilt 2, sayfa 232), ayrıca bir değeri değiştirmek, yani bir adımda bir değeri kaldırmak ve bir değer eklemek için bir formül elde edilebilir. . Testlerime göre, değiştirme iki aşamalı çıkarma / ekleme sürümünden daha iyi hassasiyet sunar.

Aşağıdaki kod Java olduğunu meanve saynı ( "küresel" üye değişkenleri) güncellenmeyen mve sJason'ın yayında yukarıda. Değer count, pencere boyutunu belirtir n.

/**
 * Replaces the value {@code x} currently present in this sample with the
 * new value {@code y}. In a sliding window, {@code x} is the value that
 * drops out and {@code y} is the new value entering the window. The sample
 * count remains constant with this operation.
 * 
 * @param x
 *            the value to remove
 * @param y
 *            the value to add
 */
public void replace(double x, double y) {
    final double deltaYX = y - x;
    final double deltaX = x - mean;
    final double deltaY = y - mean;
    mean = mean + deltaYX / count;
    final double deltaYp = y - mean;
    final double countMinus1 = count - 1;
    s = s - count / countMinus1 * (deltaX * deltaX - deltaY * deltaYp) - deltaYX * deltaYp / countMinus1;
}

Jason ve Nibot'un cevabı önemli bir açıdan farklılık gösterir: Jason'ın metodu std dev'i ve tüm sinyal için ortalamayı (y = 0'dan beri) hesaplarken, Nibot'un "çalışan" bir hesaplamasıdır, yani daha yeni numuneleri daha ağır basar. uzak geçmiş.

Uygulama std dev gerektirdiği ve zamanın bir işlevi olduğu anlamına geldiğinden, Nibot'un yöntemi muhtemelen en uygun olanıdır (bu özel uygulama için). Ancak, asıl zor kısım, zamanı doğru ölçen kısmı almak olacaktır. Nibot örneği, basit bir tek kutuplu filtre kullanmaktadır.

$E[x]$$x[n]$$E[x^2]$$x[n]^2$

Alçak geçirgen filtre seçimi, sinyaliniz ve tahmininiz için ihtiyaç duyduğunuz zaman çözünürlüğü hakkında bildikleriniz tarafından yönlendirilebilir. Düşük kesme frekansları ve daha yüksek sıra daha iyi doğrulukla sonuçlanır ancak daha yavaş tepki süresi sağlar.

İşleri daha da karmaşıklaştırmak için, doğrusal alana bir filtre ve kare alana bir başka filtre uygulanır. Kare alma, sinyalin spektral içeriğini önemli ölçüde değiştirir, böylece kare alanda farklı bir filtre kullanmak isteyebilirsiniz.

İşte zamanın bir fonksiyonu olarak ortalama, rms ve std dev'in nasıl tahmin edileceğine bir örnek.

%% example
fs = 44100; n = fs; % 44.1 kHz sample rate, 1 second
% signal: white noise plus a low frequency drift at 5 Hz)
x = randn(n,1) + sin(2*pi*(0:n-1)'*5/fs);
% mean estimation filter: since we are looking for effects in the 5 Hz range we use maybe a
% 25 Hz filter, 2nd order so it's not too sluggish
[b,a] = butter(2,25*2/fs);
xmeanEst = filter(b,a,x);
% now we estimate x^2, since most frequency double we use twice the bandwidth
[b,a] = butter(2,50*2/fs);
x2Est = filter(b,a,x.^2);
% std deviation estimate
xstd = sqrt(x2Est)-xmeanEst;
% and plot it
h = plot([x, xmeanEst sqrt(x2Est) xstd]);
grid on;
legend('x','E<x>','sqrt(E<x^2>)','Std dev');
set(h(2:4),'Linewidth',2);