Tìm trung bình chạy từ một luồng số nguyên

Có thể trùng lặp:
Thuật toán trung bình cán trong C

Cho rằng số nguyên được đọc từ một luồng dữ liệu. Tìm trung bình của các yếu tố đọc cho đến nay theo cách hiệu quả.

Giải pháp tôi đã đọc: Chúng ta có thể sử dụng một heap tối đa ở bên trái để biểu diễn các phần tử nhỏ hơn trung vị hiệu quả và một heap tối thiểu ở bên phải để biểu diễn các phần tử lớn hơn phần tử trung bình hiệu quả.

Sau khi xử lý một phần tử đến, số phần tử trong heap khác nhau nhiều nhất là 1 phần tử. Khi cả hai heap chứa cùng một số phần tử, chúng ta sẽ thấy trung bình dữ liệu gốc của heap là trung bình hiệu quả. Khi các đống không cân bằng, chúng ta chọn trung vị hiệu quả từ gốc của heap chứa nhiều phần tử.

Nhưng làm thế nào chúng ta sẽ xây dựng một đống tối đa và tối thiểu heap tức là làm thế nào chúng ta biết được trung vị hiệu quả ở đây? Tôi nghĩ rằng chúng ta sẽ chèn 1 phần tử trong heap tối đa và sau đó là phần tử tiếp theo trong heap, và cứ như vậy cho tất cả các phần tử. Sửa tôi nếu tôi sai ở đây.

Có một số giải pháp khác nhau để tìm chạy trung bình từ dữ liệu được truyền phát, tôi sẽ nói ngắn gọn về chúng ở cuối câu trả lời.

Câu hỏi là về các chi tiết của một giải pháp cụ thể (giải pháp heap tối đa / phút heap) và cách giải quyết dựa trên heap hoạt động được giải thích dưới đây:

Đối với hai phần tử đầu tiên, thêm một phần tử nhỏ hơn vào maxHeap ở bên trái và phần tử lớn hơn cho minHeap ở bên phải. Sau đó xử lý từng luồng dữ liệu,

Step 1: Add next item to one of the heaps

   if next item is smaller than maxHeap root add it to maxHeap,
   else add it to minHeap

Step 2: Balance the heaps (after this step heaps will be either balanced or
   one of them will contain 1 more item)

   if number of elements in one of the heaps is greater than the other by
   more than 1, remove the root element from the one containing more elements and
   add to the other one

Sau đó, tại bất kỳ thời điểm nào, bạn có thể tính toán trung vị như thế này:

   If the heaps contain equal amount of elements;
     median = (root of maxHeap + root of minHeap)/2
   Else
     median = root of the heap with more elements

Bây giờ tôi sẽ nói về vấn đề nói chung như đã hứa trong phần đầu của câu trả lời. Tìm kiếm trung bình chạy từ một luồng dữ liệu là một vấn đề khó khăn và việc tìm một giải pháp chính xác với các hạn chế về bộ nhớ một cách hiệu quả có lẽ là không thể đối với trường hợp chung. Mặt khác, nếu dữ liệu có một số đặc điểm chúng ta có thể khai thác, chúng ta có thể phát triển các giải pháp chuyên dụng hiệu quả. Ví dụ: nếu chúng ta biết rằng dữ liệu là một loại tích phân, thì chúng ta có thể sử dụng sắp xếp đếm, có thể cung cấp cho bạn một thuật toán thời gian liên tục bộ nhớ không đổi. Giải pháp dựa trên Heap là một giải pháp tổng quát hơn vì nó cũng có thể được sử dụng cho các loại dữ liệu khác (nhân đôi). Và cuối cùng, nếu không yêu cầu trung bình chính xác và xấp xỉ là đủ, bạn chỉ cần cố gắng ước tính hàm mật độ xác suất cho dữ liệu và ước tính trung bình sử dụng.

Nếu bạn không thể giữ tất cả các mục trong bộ nhớ cùng một lúc, vấn đề này sẽ trở nên khó khăn hơn nhiều. Giải pháp heap yêu cầu bạn giữ tất cả các phần tử trong bộ nhớ cùng một lúc. Điều này là không thể trong hầu hết các ứng dụng trong thế giới thực của vấn đề này.

Thay vào đó, như bạn thấy con số, theo dõi các số của số lần bạn nhìn thấy mỗi số nguyên. Giả sử số nguyên 4 byte, đó là 2 ^ 32 xô, hoặc nhiều nhất là 2 ^ 33 số nguyên (khóa và số đếm cho mỗi int), là 2 ^ 35 byte hoặc 32GB. Nó có thể sẽ ít hơn nhiều so với điều này bởi vì bạn không cần lưu trữ khóa hoặc tính cho những mục nhập bằng 0 (ví dụ như một defaultdict trong python). Điều này mất thời gian liên tục để chèn từng số nguyên mới.

Sau đó, tại bất kỳ điểm nào, để tìm trung vị, chỉ cần sử dụng số đếm để xác định số nguyên nào là phần tử ở giữa. Điều này cần thời gian không đổi (mặc dù một hằng số lớn, nhưng dù sao cũng không đổi).

Nếu phương sai của đầu vào được phân phối theo thống kê (ví dụ: bình thường, log-normal, v.v.) thì lấy mẫu hồ chứa là một cách hợp lý để ước tính tỷ lệ phần trăm / trung vị từ một dòng số dài tùy ý.

int n = 0;  // Running count of elements observed so far  
#define SIZE 10000
int reservoir[SIZE];  

while(streamHasData())
{
  int x = readNumberFromStream();

  if (n < SIZE)
  {
       reservoir[n++] = x;
  }         
  else 
  {
      int p = random(++n); // Choose a random number 0 >= p < n
      if (p < SIZE)
      {
           reservoir[p] = x;
      }
  }
}

"hồ chứa" sau đó là một mẫu chạy, thống nhất (công bằng), mẫu của tất cả các đầu vào - bất kể kích thước. Tìm trung vị (hoặc bất kỳ phần trăm nào) sau đó là một vấn đề đơn giản trong việc phân loại hồ chứa và bỏ phiếu điểm thú vị.

Vì hồ chứa có kích thước cố định, nên loại này có thể được coi là O (1) một cách hiệu quả - và phương pháp này chạy với cả thời gian và mức tiêu thụ bộ nhớ không đổi.

Cách hiệu quả nhất để tính phần trăm của luồng mà tôi đã tìm thấy là thuật toán P²: Raj Jain, Imrich Chlamtac: Thuật toán P² để tính toán động lượng tử và biểu đồ mà không cần lưu trữ quan sát. Cộng đồng. ACM 28 (10): 1076-1085 (1985)

Thuật toán là thẳng về phía trước để thực hiện và hoạt động rất tốt. Đó là một ước tính, tuy nhiên, vì vậy hãy ghi nhớ điều đó. Từ tóm tắt:

Một thuật toán heuristic được đề xuất cho tính toán động qf trung vị và các lượng tử khác. Các ước tính được tạo ra một cách linh hoạt khi các quan sát được tạo ra. Các quan sát không được lưu trữ; do đó, thuật toán có yêu cầu lưu trữ rất nhỏ và cố định bất kể số lượng quan sát. Điều này làm cho nó lý tưởng để thực hiện trong một chip lượng tử có thể được sử dụng trong các bộ điều khiển và máy ghi công nghiệp. Thuật toán được mở rộng hơn nữa để vẽ biểu đồ. Độ chính xác của thuật toán được phân tích.

Nếu chúng ta muốn tìm trung vị của n phần tử được nhìn thấy gần đây nhất, thì vấn đề này có một giải pháp chính xác chỉ cần n phần tử được nhìn thấy gần đây nhất được giữ trong bộ nhớ. Nó là nhanh và quy mô tốt.

Một skiplist có thể lập chỉ mục hỗ trợ chèn O (ln n), loại bỏ và tìm kiếm được lập chỉ mục các phần tử tùy ý trong khi duy trì thứ tự sắp xếp. Khi được kết hợp với hàng đợi FIFO theo dõi mục cũ nhất thứ n, giải pháp rất đơn giản:

class RunningMedian:
    'Fast running median with O(lg n) updates where n is the window size'

    def __init__(self, n, iterable):
        self.it = iter(iterable)
        self.queue = deque(islice(self.it, n))
        self.skiplist = IndexableSkiplist(n)
        for elem in self.queue:
            self.skiplist.insert(elem)

    def __iter__(self):
        queue = self.queue
        skiplist = self.skiplist
        midpoint = len(queue) // 2
        yield skiplist[midpoint]
        for newelem in self.it:
            oldelem = queue.popleft()
            skiplist.remove(oldelem)
            queue.append(newelem)
            skiplist.insert(newelem)
            yield skiplist[midpoint]

Dưới đây là các liên kết để hoàn thành mã làm việc (phiên bản lớp dễ hiểu và phiên bản trình tạo được tối ưu hóa với mã skiplist có thể lập chỉ mục được nội tuyến):

• http://code.activestate.com/recipes/576930-ffic-rucky-median-USE-an-indexable-skipli/

• http://code.activestate.com/recipes/577073 .

Một cách trực quan để suy nghĩ về điều này là nếu bạn có một cây tìm kiếm nhị phân cân bằng đầy đủ, thì gốc sẽ là phần tử trung bình, vì sẽ có cùng một số phần tử nhỏ hơn và lớn hơn. Bây giờ, nếu cây không đầy thì điều này sẽ không hoàn toàn như vậy vì sẽ có các yếu tố bị thiếu ở cấp độ cuối cùng.

Vì vậy, những gì chúng ta có thể làm thay vào đó là có trung vị và hai cây nhị phân cân bằng, một cho các phần tử nhỏ hơn trung vị và một cho các phần tử lớn hơn trung vị. Hai cây phải được giữ ở cùng kích thước.

Khi chúng tôi nhận được một số nguyên mới từ luồng dữ liệu, chúng tôi so sánh nó với trung vị. Nếu nó lớn hơn trung vị, chúng ta thêm nó vào đúng cây. Nếu hai kích thước cây khác nhau nhiều hơn 1, chúng ta sẽ loại bỏ phần tử min của cây bên phải, biến nó thành trung vị mới và đặt trung vị cũ vào cây bên trái. Tương tự cho nhỏ hơn.

Hiệu quả là một từ phụ thuộc vào ngữ cảnh. Giải pháp cho vấn đề này phụ thuộc vào số lượng truy vấn được thực hiện liên quan đến số lượng chèn. Giả sử bạn đang chèn N số và K lần vào cuối bạn quan tâm đến trung vị. Độ phức tạp của thuật toán dựa trên heap sẽ là O (N log N + K).

Hãy xem xét các phương án sau. Đặt các số trong một mảng và cho mỗi truy vấn, hãy chạy thuật toán chọn tuyến tính (sử dụng trục quicksort, giả sử). Bây giờ bạn có một thuật toán với thời gian chạy O (KN).

Bây giờ nếu K đủ nhỏ (truy vấn không thường xuyên), thuật toán sau thực sự hiệu quả hơn và ngược lại.

Bạn không thể làm điều này chỉ với một đống? Cập nhật: không. Xem bình luận.

Bất biến: Sau khi đọc các 2*nđầu vào, heap min giữ số nlớn nhất trong số chúng.

Vòng lặp: Đọc 2 đầu vào. Thêm cả hai vào heap và loại bỏ min của heap. Điều này thiết lập lại bất biến.

Vì vậy, khi 2nđầu vào đã được đọc, min của heap là lớn thứ n. Sẽ cần phải có thêm một chút phức tạp để lấy trung bình hai yếu tố xung quanh vị trí trung bình và để xử lý các truy vấn sau một số lượng đầu vào lẻ.