อัลกอริทึมที่ดีสำหรับการประมาณค่ามัธยฐานของชุดข้อมูลที่อ่านครั้งเดียวขนาดใหญ่คืออะไร?

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

การประมาณนั้นดีตราบใดที่ทราบความแม่นยำ

ตัวชี้ใด ๆ

คุณสามารถจัดกลุ่มชุดข้อมูลให้เป็นชุดข้อมูลที่เล็กกว่ามาก (เช่นจุดข้อมูล 100 หรือ 1,000 หรือ 10,000 จุด) ถ้าคุณคำนวณค่ามัธยฐานของแต่ละกลุ่ม หากคุณทำสิ่งนี้ด้วยชุดข้อมูลที่เพียงพอคุณสามารถพล็อตบางอย่างเช่นค่าเฉลี่ยของผลลัพธ์ของชุดเล็กแต่ละชุดและชุดข้อมูลนี้โดยการเรียกใช้ชุดข้อมูลขนาดเล็กพอที่จะรวมเข้ากับโซลูชัน 'เฉลี่ย'

วิธีการเกี่ยวกับบางสิ่งบางอย่างเช่นขั้นตอนการ binning? สมมติ (เพื่อจุดประสงค์ภาพประกอบ) ที่คุณรู้ว่าค่าอยู่ระหว่าง 1 ถึง 1 ล้าน ตั้งค่าถังขยะ N ของขนาด S ดังนั้นหาก S = 10,000 คุณจะมี 100 ถังขยะซึ่งสอดคล้องกับค่า [1: 10,000, 1,0001: 20000, ... , 990001: 1000000]

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

เนื่องจากคุณไม่ทราบว่ามูลค่าของคุณจะได้รับเพียงใดให้เลือกขนาดถังขยะที่มีขนาดใหญ่พอที่คุณจะไม่มีหน่วยความจำเหลืออยู่โดยใช้การคำนวณแบบย้อนกลับอย่างรวดเร็ว นอกจากนี้คุณยังอาจเก็บถังขยะเบาบางเช่นที่คุณเพิ่มถังถ้ามันมีค่า

แก้ไข:

ลิงก์ ryfm ให้ตัวอย่างของการทำเช่นนี้ด้วยขั้นตอนเพิ่มเติมของการใช้เปอร์เซ็นต์สะสมเพื่อประเมินจุดภายใน median bin ให้แม่นยำยิ่งขึ้นแทนที่จะใช้จุดกึ่งกลาง นี่คือการปรับปรุงที่ดี

$O(n)$

อัลกอริทึม Rivest-Tarjan เลือก (บางครั้งเรียกว่าค่ามัธยฐานของอัลกอริทึมมีเดีย) จะช่วยให้คุณคำนวณองค์ประกอบเฉลี่ยในเชิงเส้นเวลาโดยไม่ต้องเรียงลำดับใด ๆ สำหรับชุดข้อมูลขนาดใหญ่สิ่งนี้สามารถทำได้เร็วกว่าการจัดเรียงบันทึกเชิงเส้น อย่างไรก็ตามมันจะไม่แก้ปัญหาการจัดเก็บหน่วยความจำของคุณ

ผมดำเนินการP-จัตุรัสอัลกอริทึมสำหรับการคำนวณแบบไดนามิกและควอนไท Histograms โดยไม่ต้องจัดเก็บข้อสังเกตในโมดูลหลามเรียบร้อยผมเขียนเรียกว่าLiveStats มันควรจะแก้ปัญหาของคุณได้อย่างมีประสิทธิภาพทีเดียว

ฉันไม่เคยทำเช่นนี้ดังนั้นนี่เป็นเพียงข้อเสนอแนะ

ฉันเห็นความเป็นไปได้สองอย่าง (อื่น ๆ )

ข้อมูลครึ่งหนึ่ง

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

การกระจายตัวตัวอย่าง

ตัวเลือกอื่นคือใช้การประมาณที่เกี่ยวข้องกับการแจกแจงตัวอย่าง ถ้าข้อมูลของคุณเป็นปกติแล้วข้อผิดพลาดมาตรฐานปานกลางnคือ:

1.253 * sd / sqrt (n)

เพื่อกำหนดขนาดของnที่คุณจะมีความสุขฉันใช้การจำลองแบบมอนติคาร์โลอย่างรวดเร็วใน R

n = 10000
outside.ci.uni = 0
outside.ci.nor = 0
N=1000
for(i in 1:N){
  #Theoretical median is 0
  uni = runif(n, -10, 10)
  nor  = rnorm(n, 0, 10)

  if(abs(median(uni)) > 1.96*1.253*sd(uni)/sqrt(n))
    outside.ci.uni = outside.ci.uni + 1

  if(abs(median(nor)) > 1.96*1.253*sd(nor)/sqrt(n))
    outside.ci.nor = outside.ci.nor + 1
}

outside.ci.uni/N
outside.ci.nor/N

สำหรับ n = 10,000, 15% ของค่ามัธยฐานของค่าเครื่องแบบอยู่นอก CI

คุณสามารถลองหาค่ามัธยฐานตามการแจกแจงความถี่ที่จัดกลุ่มแล้วนี่คือรายละเอียดบางอย่าง

ต่อไปนี้เป็นคำตอบของคำถามที่ถามเกี่ยวกับ stackoverflow: https://stackoverflow.com/questions/1058813/on-line-iterator-algorithms-for-estimating-statistical-median-mode-skewness/2144754#2144754

ค่ามัธยฐานการปรับปรุงซ้ำ + = eta * sgn (ตัวอย่าง - ค่ามัธยฐาน) ดูเหมือนว่าอาจเป็นวิธีที่จะไป

Remedian อัลกอริทึม (PDF)ให้ประมาณการค่ามัธยฐานหนึ่งผ่านที่มีความต้องการจัดเก็บข้อมูลที่ต่ำและความถูกต้องกำหนดไว้อย่างดี

การเยียวยาด้วยฐานขดำเนินการโดยการคำนวณค่ามัธยฐานของกลุ่มการสังเกต b จากนั้นค่ามัธยฐานของค่ามัธยฐานเหล่านี้จนกระทั่งเหลือเพียงค่าประมาณเดียว วิธีนี้ต้องการเพียงอาร์เรย์ k ของขนาด b (โดยที่ n = b ^ k) ...

หากค่าที่คุณใช้อยู่ในช่วงที่กำหนดให้บอกว่า 1 ถึง 100000 คุณสามารถคำนวณค่ามัธยฐานของค่าจำนวนมากได้อย่างมีประสิทธิภาพ (พูดจำนวนล้านรายการ) ด้วยที่เก็บข้อมูลจำนวนเต็ม (รหัสนี้นำมาจาก BSD ที่ได้รับอนุญาต BSD -utils / sam-stats.cpp)

class ibucket {
public:
    int tot;
    vector<int> dat;
    ibucket(int max) {dat.resize(max+1);tot=0;}
    int size() const {return tot;};

    int operator[] (int n) const {
        assert(n < size());
        int i;
        for (i=0;i<dat.size();++i) {
            if (n < dat[i]) {
                return i;
            }
            n-=dat[i];
        }
    }

    void push(int v) {
        assert(v<dat.size());
        ++dat[v];
        ++tot;
    }
};


template <class vtype>
double quantile(const vtype &vec, double p) {
        int l = vec.size();
        if (!l) return 0;
        double t = ((double)l-1)*p;
        int it = (int) t;
        int v=vec[it];
        if (t > (double)it) {
                return (v + (t-it) * (vec[it+1] - v));
        } else {
                return v;
        }
}