Đặt vì vậy đối với một mẫu rất ngắn như { 1 , 3 , 6 , 2 , 7 , 5 } có thể được tính từ việc tìm tĩnh thứ tự thứ k có sự khác biệt theo cặp: $Q_n = C_n.\{|X_i-X_j|;i < j\}_{(k)}$$\{1,3,6,2,7,5\}$$k$

    7 6 5 3 2 1
1   6 5 4 2 1
2   5 4 3 1
3   4 3 2
5   2 1
6   1
7

h = [n / 2] + 1 = 4

k = h (h-1) / 2 = 8

Do đó $Q_n=C_n. 2$

Rõ ràng đối với các mẫu lớn nói bao gồm 80.000 hồ sơ, chúng ta cần bộ nhớ rất lớn.

Có cách nào để tính trong không gian 1D thay vì 2D không?$Q_n$

Một liên kết đến câu trả lời ftp://ftp.win.ua.ac.be/pub/preprints/92/Timeff92.pdf mặc dù tôi không thể hiểu hết về nó.

Cập nhật: Mấu chốt của vấn đề là để đạt được độ phức tạp thời gian $O(n\log(n))$ , người ta cần theo thứ tự lưu trữ $O(n)$ .

Không, $O(n\log(n))$ là giới hạn lý thuyết thấp hơn cho độ phức tạp thời gian của (xem (1)) chọn phần tử $k^{th}$ trong số tất cả $\frac{n(n-1)}{2}$ có thể$|x_i - x_j|: 1 \leq i \lt j \leq n$.

Bạn có thể nhận được không gian $O(1)$ , nhưng chỉ bằng cách kiểm tra ngây thơ tất cả các kết hợp của $x_i-x_j$ trong thời gian $O(n^2)$ .

Tin vui là bạn có thể sử dụng $\tau$ cụ ước tính tỷ lệ (xem (2) và (3) cho phiên bản cải tiến và một số so sánh thời gian), được triển khai trong chức năng scaleTau2()trong Rgói robustbase. Các đơn biến $\tau$ ước lượng là một hai bước (tức là tái-weighted) ước lượng quy mô. Nó có hiệu suất Gaussian 95 phần trăm, điểm phân tích 50 phần trăm và độ phức tạp của thời gian $O(n)$ và không gian $O(1)$ (cộng với nó có thể dễ dàng thực hiện 'trực tuyến', loại bỏ một nửa chi phí tính toán khi sử dụng nhiều lần - mặc dù bạn sẽ phải đào sâu vào Rmã để thực hiện tùy chọn này, nó khá đơn giản để làm).

1. Sự phức tạp của việc lựa chọn và xếp hạng trong X + Y và ma trận với các cột được sắp xếp GN Frederickson và DB Johnson, Tạp chí Khoa học Máy tính và Hệ thống Tập 24, Số 2, Tháng 4 năm 1982, Trang 197-208.
2. Yohai, V. và Zamar, R. (1988). Ước tính điểm phân tích cao của hồi quy bằng phương pháp tối thiểu hóa thang đo hiệu quả. Tạp chí của Hiệp hội Thống kê Hoa Kỳ 83 406 Từ413.
3. Maronna, R. và Zamar, R. (2002). Ước tính mạnh mẽ về vị trí và độ phân tán cho các tập dữ liệu chiều cao. Kỹ thuật 44 307 Điện317

Chỉnh sửa Để sử dụng

1. Bật lên R(miễn phí và có thể tải xuống từ đây )
2. Cài đặt gói bằng cách gõ:

install.packages("robustbase")

3. Tải gói bằng cách gõ:

library("robustbase")

4. Tải tệp dữ liệu của bạn và chạy chức năng:

mydatavector <- read.table("address to my file in text format", header=T)
scaleTau2(mydatavector)

(Câu trả lời rất ngắn) Văn bản để bình luận nói

tránh trả lời các câu hỏi trong ý kiến.

Vì vậy, đây là: Có một bài viết về một thuật toán trực tuyến dường như chạy khá tốt: Áp dụng Công cụ Ước tính Trực tuyến$Q_n$ .

BIÊN TẬP

(bởi người dùng603). Thuật toán được liên kết trong bài viết này là phiên bản cửa sổ chuyển động của .$Q_n$

Cho một mẫu lớn được chia thành các cửa sổ thời gian có chiều rộng n < N , { x i } t i = t - n + 1, chúng ta có thể áp dụng Q n cho mỗi cửa sổ thời gian mang lại N - n + 1 các giá trị của Q n . Suy ra các giá trị này { Q i n } N - n + $\{x_i\}_{i=1}^N$$n<N$$\{x_i\}_{i=t-n+1}^t$$Q_n$$N-n+1$$Q_n$$\{Q_n^i\}_{i=1}^{N-n+1}$

$Q_n^i|Q_n^{i-1}$ $O(n\log(n))$$Q_n^i$

$Q_n$$\{x_i\}_{i=1}^N$$O(n^2)$ (mặc dù nó thường nhỏ hơn nhiều).

đây là triển khai của tôi về Qn ...

Tôi đã lập trình điều này trong C và kết quả là:

void bubbleSort(double *datos, int N)
{
 for (int j=0; j<N-1 ;j++)     
  for (int i=j+1; i<N; i++)    
   if (datos[i]<datos[j])      
   {
    double tmp=datos[i];
    datos[i]=datos[j];
    datos[j]=tmp;
   }
}

double  fFactorial(long N)    
{
 double factorial=1.0;

 for (long i=1; i<=N; ++i)
  factorial*=(double)i;

 return factorial;  
}

double fQ_n(double *datos, int N)  // Rousseeuw's and Croux (1993) Qn scale estimator
{
 bubbleSort(datos, N);

 int m=(int)((fFactorial((long)N))/(fFactorial(2)*fFactorial((long)N-2)));

 double D[m];
 //double Cn=2.2219;      //not used now :) constant value https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/qn_scale.htm

 int k=(int)((fFactorial((long)N/2+1))/(fFactorial(2)*fFactorial((long)N/2+1-2)));

 int y=0;

 for (int i=0; i<N; i++)
  for (int j=N-1; j>=0; j--)
   if (i<j)
   {
    D[y]=abs(datos[i]-datos[j]);
    y++;
   }

 bubbleSort(D, m);

 return D[k-1];
}

int main(int argc, char **argv)    
{
 double datos[6]={1,2,3,5,6,7};
 int N=6;

 // Priting in terminal the final solution
 printf("\n==[Results] ========================================\n\n");

 printf(" Q_n=%0.3f\n",fQ_n(datos,N));

 return 0;
}