การกำหนดค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานแบบเรียลไทม์

อะไรจะเป็นวิธีที่เหมาะในการค้นหาค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานของสัญญาณสำหรับแอปพลิเคชันตามเวลาจริง ฉันต้องการที่จะทริกเกอร์คอนโทรลเลอร์เมื่อสัญญาณมีค่าเบี่ยงเบนมาตรฐานมากกว่า 3 จากค่าเฉลี่ยในระยะเวลาหนึ่ง

ฉันสมมติว่า DSP โดยเฉพาะจะทำสิ่งนี้ได้อย่างง่ายดาย แต่มี "ทางลัด" ใด ๆ ที่อาจไม่ต้องการอะไรที่ซับซ้อนขนาดนี้หรือไม่?

มีข้อบกพร่องในคำตอบของ Jason R ซึ่งถูกกล่าวถึงในบท "Art of Computer Programming" ของ Knuth 2. ปัญหาเกิดขึ้นหากคุณมีค่าเบี่ยงเบนมาตรฐานซึ่งเป็นส่วนเล็ก ๆ ของค่าเฉลี่ย: การคำนวณ E (x ^ 2) - (E (x) ^ 2) ได้รับความทุกข์ทรมานจากความไวที่รุนแรงถึงข้อผิดพลาดในการปัดเศษทศนิยม

คุณสามารถลองด้วยตัวคุณเองในสคริปต์ Python:

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

ฉันได้รับ -128.0 เป็นคำตอบซึ่งเห็นได้ชัดว่าไม่ถูกต้องในการคำนวณเนื่องจากคณิตศาสตร์ทำนายว่าผลลัพธ์ควรไม่เป็นค่าลบ

Knuth อ้างอิงแนวทาง (ฉันจำชื่อผู้ประดิษฐ์ไม่ได้) สำหรับการคำนวณค่าเฉลี่ยการทำงานและส่วนเบี่ยงเบนมาตรฐานซึ่งมีลักษณะดังนี้:

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

และหลังจากแต่ละขั้นตอนแล้วค่าของmคือค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานสามารถคำนวณตามsqrt(S/n)หรือsqrt(S/n-1)ขึ้นอยู่กับคำจำกัดความที่คุณชื่นชอบของส่วนเบี่ยงเบนมาตรฐาน

สมการที่ฉันเขียนด้านบนนั้นแตกต่างจากที่ Knuth เล็กน้อย แต่มันเทียบเท่ากับการคำนวณ

เมื่อฉันมีเวลาอีกไม่กี่นาทีฉันจะเขียนสูตรสูตรข้างต้นใน Python และแสดงว่าคุณจะได้รับคำตอบที่ไม่จำเป็น (หวังว่าจะใกล้เคียงกับค่าที่ถูกต้อง)

update: นี่มันคือ

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)

ผล:

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}

คุณจะได้ทราบว่ายังคงมีข้อผิดพลาดบางปัดเศษ แต่มันก็ไม่ได้เลวร้ายในขณะที่naive_statsเพียง pukes

แก้ไข: เพิ่งสังเกตเห็นความคิดเห็นของเบลิซาเรียสอ้างถึงวิกิพีเดียซึ่งพูดถึงอัลกอริธึมของ Knuth

อะไรจะเป็นวิธีที่เหมาะในการค้นหาค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานของสัญญาณสำหรับแอปพลิเคชันตามเวลาจริง ฉันต้องการที่จะทริกเกอร์คอนโทรลเลอร์เมื่อสัญญาณมีค่าเบี่ยงเบนมาตรฐานมากกว่า 3 จากค่าเฉลี่ยในระยะเวลาหนึ่ง

วิธีการที่เหมาะสมในสถานการณ์เช่นนี้โดยทั่วไปคือการคำนวณหาค่าเฉลี่ยการวิ่งและค่าเบี่ยงเบนมาตรฐาน ในค่าเฉลี่ยถ่วงน้ำหนักแบบเอ็กซ์โปเนนเชียลค่าประมาณของค่าเฉลี่ยและความแปรปรวนจะมีอคติกับตัวอย่างล่าสุดที่ให้ค่าประมาณของค่าเฉลี่ยและความแปรปรวนในช่วงวินาทีสุดท้าย$\tau$ซึ่งอาจเป็นสิ่งที่คุณต้องการมากกว่าค่าเฉลี่ยเลขคณิตทั่วไป ตัวอย่างที่เคยเห็น

ในโดเมนความถี่ "ค่าเฉลี่ยถ่วงน้ำหนักการทำงานแบบเอ็กซ์โปเนนเชียล" เป็นเพียงเสาจริง มันง่ายที่จะใช้ในโดเมนเวลา

การใช้โดเมนเวลา

อนุญาตmeanและmeansqเป็นค่าประมาณปัจจุบันของค่าเฉลี่ยและค่าเฉลี่ยของกำลังสองของสัญญาณ ทุกรอบให้อัปเดตค่าประมาณเหล่านี้ด้วยตัวอย่างใหม่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);

ที่นี่เป็นค่าคงที่ที่กำหนดความยาวที่มีประสิทธิภาพของค่าเฉลี่ยการวิ่ง วิธีเลือกอธิบายไว้ด้านล่างใน "การวิเคราะห์"$0 < a < 1$$a$

สิ่งที่แสดงไว้ข้างต้นในฐานะโปรแกรมที่จำเป็นอาจถูกอธิบายเป็นไดอะแกรมสัญญาณการไหล:

การวิเคราะห์

อัลกอริทึมด้านบนคำนวณโดยที่คืออินพุตที่ตัวอย่างและคือเอาต์พุต (ประมาณค่าเฉลี่ยของค่าเฉลี่ย) นี่เป็นตัวกรอง IIR แบบเสาเดี่ยวที่เรียบง่าย การเปลี่ยนเราพบฟังก์ชันถ่ายโอน1}}$y_i = a x_i + (1-a) y_{i-1}$$x_i$$i$$y_i$$z$

กลั่นตัวกรอง IIR ลงในบล็อกของตัวเองไดอะแกรมจะมีลักษณะดังนี้:

หากต้องการไปยังโดเมนต่อเนื่องเราทำการแทนที่โดยที่คือเวลาตัวอย่างและคืออัตราตัวอย่าง การแก้เราจะพบว่าระบบอย่างต่อเนื่องมีเสาที่(1-A) $z = e^{s T}$$T$$f_s = 1/T$$1-(1-a)e^{-sT}=0$$s = \frac{1}{T} \log (1-a)$

เลือก:$a$

อ้างอิง

• แหล่งแผนภาพ Simulink สามารถดาวน์โหลดได้จากhttps://gist.github.com/1942771

วิธีที่ฉันใช้ก่อนหน้านี้ในแอปพลิเคชันการประมวลผลแบบฝังตัวคือการรักษาการสะสมของผลรวมและผลรวมของกำลังสองของสัญญาณที่น่าสนใจ:

นอกจากนี้ติดตามการทันทีเวลาปัจจุบันในสมการข้างต้น (นั่นคือทราบจำนวนตัวอย่างที่คุณเพิ่มเข้าไปสะสมที่) จากนั้นค่าเฉลี่ยตัวอย่างและค่าเบี่ยงเบนมาตรฐาน ณ เวลาที่เป็น:$i$$i$

หรือคุณสามารถใช้:

ซึ่งขึ้นอยู่กับวิธีการประมาณค่าส่วนเบี่ยงเบนมาตรฐานที่คุณต้องการ สมการเหล่านี้ตั้งอยู่บนพื้นฐานของนิยามของความแปรปรวน :

ฉันเคยใช้สิ่งเหล่านี้สำเร็จแล้วในอดีต (แม้ว่าฉันจะเกี่ยวข้องกับการประมาณค่าความแปรปรวนไม่ใช่ค่าเบี่ยงเบนมาตรฐาน) แต่คุณต้องระวังเกี่ยวกับประเภทตัวเลขที่คุณใช้เพื่อเก็บสะสมถ้าคุณจะสรุป เป็นเวลานาน คุณไม่ต้องการล้น

แก้ไข:นอกเหนือจากความคิดเห็นข้างต้นเกี่ยวกับการโอเวอร์โฟลว์แล้วมันควรจะสังเกตว่านี่ไม่ใช่อัลกอริธึมเชิงตัวเลขเมื่อนำมาใช้ในการคำนวณเลขทศนิยมซึ่งอาจทำให้เกิดข้อผิดพลาดขนาดใหญ่ในสถิติโดยประมาณ ดูคำตอบของ Jason S สำหรับวิธีการที่ดีกว่าในกรณีนั้น

เช่นเดียวกับคำตอบที่ต้องการข้างต้น (Jason S. ) และยังได้มาจากสูตรที่นำมาจาก Knut (เล่ม 2, หน้า 232) เรายังสามารถหาสูตรเพื่อแทนที่ค่าเช่นลบและเพิ่มค่าในขั้นตอนเดียว . ตามการทดสอบของฉันแทนที่ให้ความแม่นยำที่ดีกว่าการลบ / เพิ่มสองขั้นตอน

รหัสด้านล่างนี้อยู่ใน Java meanและsรับการปรับปรุง (ตัวแปรสมาชิก "global") เหมือนกับmและsข้างบนในโพสต์ของ Jason ค่าหมายถึงขนาดของหน้าต่างcountn

/**
 * 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 และ Nibot นั้นแตกต่างกันในด้านที่สำคัญอย่างหนึ่ง: วิธีการของ Jason คำนวณ std dev และค่าเฉลี่ยของสัญญาณทั้งหมด (ตั้งแต่ y = 0) ในขณะที่ Nibot นั้นเป็นการคำนวณ "กำลังทำงาน" นั่นคือน้ำหนักตัวอย่างล่าสุดที่แข็งแกร่งกว่าตัวอย่างจาก อดีตอันไกลโพ้น

เนื่องจากแอปพลิเคชันดูเหมือนจะต้องการ std dev และหมายความว่าเป็นฟังก์ชันของเวลาวิธีการของ Nibot อาจเป็นวิธีที่เหมาะสมกว่า (สำหรับแอปพลิเคชันเฉพาะนี้) อย่างไรก็ตามส่วนที่ยากจริงจะได้รับส่วนถ่วงเวลาที่เหมาะสม ตัวอย่างของ Nibot ใช้ตัวกรองขั้วเดี่ยวอย่างง่าย

วิธีการที่เหมาะสมในการอธิบายนี้คือการที่เราได้รับการประมาณการของโดยการกรองและประมาณการสำหรับโดยการกรอง 2 โดยทั่วไปตัวกรองการประมาณจะเป็นตัวกรองความถี่ต่ำ ตัวกรองเหล่านี้ควรถูกปรับสัดส่วนเพื่อให้ได้รับ 0dB ที่ 0 Hz มิฉะนั้นจะมีข้อผิดพลาดเกนคงที่x [ n ] E [ x 2 ] x [ n ] $E[x]$$x[n]$$E[x^2]$$x[n]^2$

ตัวเลือกของตัวกรอง lowpass สามารถนำโดยสิ่งที่คุณรู้เกี่ยวกับสัญญาณและความละเอียดของเวลาที่คุณต้องการสำหรับการประเมินของคุณ ความถี่ตัดต่ำและลำดับสูงขึ้นจะส่งผลให้ความแม่นยำดีขึ้น แต่เวลาตอบสนองช้าลง

ในการทำให้สิ่งต่าง ๆ มีความซับซ้อนยิ่งขึ้นตัวกรองหนึ่งตัวจะถูกนำไปใช้ในโดเมนเชิงเส้น Squaring จะเปลี่ยนเนื้อหาสเปกตรัมของสัญญาณอย่างมีนัยสำคัญดังนั้นคุณอาจต้องการใช้ตัวกรองอื่นในโดเมนกำลังสอง

นี่คือตัวอย่างเกี่ยวกับวิธีการประมาณค่าเฉลี่ย rms และ std dev เป็นฟังก์ชันของเวลา

%% 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);