Một thuật toán tốt để ước tính trung vị của một tập dữ liệu đọc một lần rất lớn là gì?

Tôi đang tìm kiếm một thuật toán tốt (có nghĩa là tính toán tối thiểu, yêu cầu lưu trữ tối thiểu) để ước tính trung vị của một tập dữ liệu quá lớn để lưu trữ, sao cho mỗi giá trị chỉ có thể được đọc một lần (trừ khi bạn lưu trữ rõ ràng giá trị đó). Không có giới hạn về dữ liệu có thể được giả định.

Xấp xỉ là tốt, miễn là độ chính xác được biết đến.

Bất kỳ con trỏ?

Bạn có thể nhóm tập dữ liệu thành các tập dữ liệu nhỏ hơn nhiều không (giả sử 100 hoặc 1000 hoặc 10.000 điểm dữ liệu) Nếu sau đó bạn tính trung bình của từng nhóm. Nếu bạn đã làm điều này với đủ bộ dữ liệu, bạn có thể vẽ một cái gì đó như trung bình kết quả của từng bộ nhỏ hơn và con woul này, bằng cách chạy đủ bộ dữ liệu nhỏ hơn hội tụ đến một giải pháp 'trung bình'.

Làm thế nào về một cái gì đó như một thủ tục binning? Giả sử (cho mục đích minh họa) mà bạn biết rằng các giá trị nằm trong khoảng từ 1 đến 1 triệu. Thiết lập N thùng, có kích thước S. Vì vậy, nếu S = 10000, bạn sẽ có 100 thùng, tương ứng với các giá trị [1: 10000, 10001: 20000, ..., 990001: 1000000]

Sau đó, bước qua các giá trị. Thay vì lưu trữ từng giá trị, chỉ cần tăng bộ đếm trong thùng thích hợp. Sử dụng trung điểm của mỗi thùng làm ước tính, bạn có thể đưa ra xấp xỉ hợp lý của trung vị. Bạn có thể chia tỷ lệ này thành độ phân giải mịn hoặc thô như bạn muốn bằng cách thay đổi kích thước của các thùng. Bạn chỉ bị giới hạn bởi bao nhiêu bộ nhớ.

Vì bạn không biết giá trị của mình có thể lớn đến mức nào, chỉ cần chọn kích thước thùng đủ lớn để bạn không bị hết bộ nhớ, sử dụng một số tính toán ngược nhanh chóng. Bạn cũng có thể lưu trữ các thùng một cách thưa thớt, sao cho bạn chỉ thêm một thùng nếu nó chứa một giá trị.

Biên tập:

Liên kết ryfm cung cấp một ví dụ về việc này, với bước bổ sung là sử dụng tỷ lệ phần trăm tích lũy để ước tính chính xác hơn điểm trong thùng trung vị, thay vì chỉ sử dụng điểm giữa. Đây là một cải tiến tốt đẹp.

$O(n)$

Các thuật toán Rivest-Tarjan-Selection (đôi khi còn được gọi là trung bình-of-trung vị thuật toán) sẽ cho phép bạn tính toán các yếu tố trung bình trong thời gian tuyến tính mà không cần bất kỳ phân loại. Đối với các tập dữ liệu lớn, việc này có thể nhanh hơn một chút so với sắp xếp theo tuyến tính. Tuy nhiên, nó sẽ không giải quyết vấn đề lưu trữ bộ nhớ của bạn.

Tôi đã triển khai Thuật toán P-Square để tính toán động lượng tử và biểu đồ mà không lưu trữ các quan sát trong một mô-đun Python gọn gàng mà tôi đã viết có tên LiveStats . Nó sẽ giải quyết vấn đề của bạn khá hiệu quả.

Tôi chưa bao giờ phải làm điều này, vì vậy đây chỉ là một gợi ý.

Tôi thấy hai khả năng (khác).

Một nửa dữ liệu

1. Tải một nửa dữ liệu và sắp xếp
2. Tiếp theo đọc các giá trị còn lại và so sánh với danh sách đã sắp xếp của bạn.
   1. Nếu giá trị mới lớn hơn, loại bỏ nó.
   2. khác đặt giá trị trong danh sách được sắp xếp và loại bỏ giá trị lớn nhất khỏi danh sách đó.

Phân phối lấy mẫu

Tùy chọn khác, là sử dụng một xấp xỉ liên quan đến phân phối lấy mẫu. Nếu dữ liệu của bạn là Bình thường, thì lỗi tiêu chuẩn cho n vừa phải là:

1,253 * sd / sqrt (n)

Để xác định kích thước của n mà bạn sẽ hài lòng, tôi đã chạy mô phỏng Monte-Carlo nhanh trong 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

Với n = 10000, 15% ước tính trung bình thống nhất nằm ngoài CI.

Bạn có thể thử tìm một trung vị dựa trên phân phối tần số được nhóm lại, đây là một số chi tiết

Đây là câu trả lời cho câu hỏi được hỏi về stackoverflow: https://stackoverflow.com/questions/1058813/on-line-iterator-alerskyms-for-estimating-statistic-median-mode-skewness/2144754#2144754

Bản cập nhật lặp lại trung vị + = eta * sgn (mẫu - trung vị) nghe có vẻ là một cách để đi.

Các Remedian Algorithm (PDF) đưa ra một một vượt qua ước tính trung bình với nhu cầu lưu trữ thấp và độ chính xác được xác định rõ.

Người sửa chữa với cơ sở b tiến hành bằng cách tính toán trung vị của các nhóm quan sát b, và sau đó là trung vị của các trung vị này, cho đến khi chỉ còn một ước tính duy nhất. Phương pháp này chỉ cần k mảng có kích thước b (trong đó n = b ^ k) ...

Nếu các giá trị bạn đang sử dụng nằm trong một phạm vi nhất định, giả sử từ 1 đến 100000, bạn có thể tính toán trung bình một cách hiệu quả số lượng giá trị cực lớn (giả sử là hàng nghìn tỷ mục), với một số nguyên (mã này được lấy từ BSD được cấp phép -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;
        }
}