Jarak Mahalanobis berpasangan

Saya perlu menghitung jarak sampel Mahalanobis dalam R antara setiap pasangan pengamatan dalam matriks kovariat . Saya memerlukan solusi yang efisien, yaitu hanya jarak yang dihitung, dan lebih baik diimplementasikan dalam C / RCpp / Fortran dll. Saya berasumsi bahwa , matriks kovarian populasi, tidak diketahui dan menggunakan sampel matriks kovarians sebagai gantinya.n ( n - 1 ) / 2 $n \times p$$n(n-1)/2$$\Sigma$

Saya sangat tertarik pada pertanyaan ini karena tampaknya tidak ada metode "konsensus" untuk menghitung jarak Mahalanobis berpasangan dalam R, yaitu tidak diterapkan dalam distfungsi maupun dalam cluster::daisyfungsi. The mahalanobisfungsi tidak menghitung jarak berpasangan tanpa pekerjaan tambahan dari programmer.

Ini sudah diminta di sini jarak Pairwise Mahalanobis di R , tetapi solusi di sana tampaknya salah.

Berikut adalah metode yang benar tetapi sangat tidak efisien (karena jarak dihitung):$n \times n$

set.seed(0)
x0 <- MASS::mvrnorm(33,1:10,diag(c(seq(1,1/2,l=10)),10))
dM = as.dist(apply(x0, 1, function(i) mahalanobis(x0, i, cov = cov(x0))))

Ini cukup mudah untuk kode diri saya di C, tapi saya merasa seperti sesuatu yang dasar ini harus memiliki solusi yang sudah ada sebelumnya. Apakah ada satu?

Ada solusi lain yang gagal: HDMD::pairwise.mahalanobis()menghitung jarak, ketika hanya jarak unik yang diperlukan. tampaknya menjanjikan, tetapi saya tidak ingin fungsi saya berasal dari paket yang tergantung , yang sangat membatasi kemampuan orang lain untuk menjalankan kode saya. Kecuali jika implementasi ini sempurna, saya lebih suka menulis sendiri. Adakah yang punya pengalaman dengan fungsi ini?n ( n - 1 ) /$n \times n$$n(n-1)/2$compositions::MahalanobisDist()rgl

Mulai dari solusi "succint" ahfoss, saya telah menggunakan dekomposisi Cholesky sebagai pengganti SVD.

cholMaha <- function(X) {
 dec <- chol( cov(X) )
 tmp <- forwardsolve(t(dec), t(X) )
 dist(t(tmp))
}

Itu harus lebih cepat, karena penyelesaian-maju sistem segitiga lebih cepat daripada perkalian matriks padat dengan kovarians terbalik ( lihat di sini ). Berikut adalah tolok ukur dengan solusi ahfoss dan whuber di beberapa pengaturan:

 require(microbenchmark)
 set.seed(26565)
 N <- 100
 d <- 10

 X <- matrix(rnorm(N*d), N, d)

 A <- cholMaha( X = X ) 
 A1 <- fastPwMahal(x1 = X, invCovMat = solve(cov(X))) 
 sum(abs(A - A1)) 
 # [1] 5.973666e-12  Ressuring!

   microbenchmark(cholMaha(X),
                  fastPwMahal(x1 = X, invCovMat = solve(cov(X))),
                  mahal(x = X))
Unit: microseconds
expr          min       lq   median       uq      max neval
cholMaha    502.368 508.3750 512.3210 516.8960  542.806   100
fastPwMahal 634.439 640.7235 645.8575 651.3745 1469.112   100
mahal       839.772 850.4580 857.4405 871.0260 1856.032   100

 N <- 10
 d <- 5
 X <- matrix(rnorm(N*d), N, d)

   microbenchmark(cholMaha(X),
                  fastPwMahal(x1 = X, invCovMat = solve(cov(X))),
                  mahal(x = X)
                    )
Unit: microseconds
expr          min       lq    median       uq      max neval
cholMaha    112.235 116.9845 119.114 122.3970  169.924   100
fastPwMahal 195.415 201.5620 205.124 208.3365 1273.486   100
mahal       163.149 169.3650 172.927 175.9650  311.422   100

 N <- 500
 d <- 15
 X <- matrix(rnorm(N*d), N, d)

   microbenchmark(cholMaha(X),
                  fastPwMahal(x1 = X, invCovMat = solve(cov(X))),
                  mahal(x = X)
                    )
Unit: milliseconds
expr          min       lq     median       uq      max neval
cholMaha    14.58551 14.62484 14.74804 14.92414 41.70873   100
fastPwMahal 14.79692 14.91129 14.96545 15.19139 15.84825   100
mahal       12.65825 14.11171 39.43599 40.26598 41.77186   100

 N <- 500
 d <- 5
 X <- matrix(rnorm(N*d), N, d)

   microbenchmark(cholMaha(X),
                  fastPwMahal(x1 = X, invCovMat = solve(cov(X))),
                  mahal(x = X)
                    )
Unit: milliseconds
expr           min        lq      median        uq       max neval
cholMaha     5.007198  5.030110  5.115941  5.257862  6.031427   100
fastPwMahal  5.082696  5.143914  5.245919  5.457050  6.232565   100
mahal        10.312487 12.215657 37.094138 37.986501 40.153222   100

Jadi Cholesky tampaknya lebih cepat seragam.

Rumus standar untuk jarak Mahalanobis kuadrat antara dua titik data adalah

$$D_{12} = (x_1-x_2)^T \Sigma^{-1} (x_1-x_2)$$

di mana adalah vektor p × 1 yang sesuai dengan observasi i . Biasanya, matriks kovarians diperkirakan dari data yang diamati. Tidak menghitung inversi matriks, operasi ini membutuhkan p 2 + p perkalian dan p 2 + 2 p penambahan, masing-masing diulang n ( n - 1 ) / 2 kali.$x_i$$p \times 1$$i$$p^2+p$$p^2+2p$$n(n-1)/2$

Pertimbangkan derivasi berikut:

$$\begin{eqnarray*} D_{12} &=& (x_1-x_2)^T \Sigma^{-1} (x_1-x_2) \\ &=& (x_1-x_2)^T \Sigma^{-\frac{1}{2}} \Sigma^{-\frac{1}{2}} (x_1-x_2) \\ &=& (x_1^T \Sigma^{-\frac{1}{2}} - x_2^T \Sigma^{-\frac{1}{2}}) (\Sigma^{-\frac{1}{2}}x_1 - \Sigma^{-\frac{1}{2}}x_2) \\ &=& (q_1^T - q_2^T)(q_1 - q_2) \end{eqnarray*}$$

di mana . Perhatikan bahwaxTiΣ-$q_i = \Sigma^{-\frac{1}{2}}x_i$. Ini bergantung pada fakta bahwaΣ-$x_i^T \Sigma^{-\frac{1}{2}} = (\Sigma^{-\frac{1}{2}} x_i)^T = q_i^T$ adalah simetris, yang berlaku karena fakta bahwa untuk setiap matriks yang dapat didiagonalisasi simetrisA=PEPT,$\Sigma^{-\frac{1}{2}}$$A = PEP^T$

$$\begin{eqnarray*} A^{\frac{1}{2}^T} &=& (PE^{\frac{1}{2}}P^T)^T \\ &=& P^{T^T} E^{\frac{1}{2}^T} P^T \\ &=& PE^{\frac{1}{2}}P^T \\ &=& A^{\frac{1}{2}} \end{eqnarray*}$$

Jika kita membiarkan , dan perhatikan bahwa Σ - 1 simetris, kita melihat bahwa Σ - $A=\Sigma^{-1}$$\Sigma^{-1}$ juga harus simetris. JikaXadalahmatriks pengamatann×pdanQadalahmatriksn×psedemikian rupa sehingga barisithdariQadalahqi, makaQdapat secara ringkas dinyatakan sebagaiXΣ-$\Sigma^{-\frac{1}{2}}$$X$$n \times p$$Q$$n \times p$$i^{th}$$Q$$q_i$$Q$ . Ini dan hasil sebelumnya menyiratkan itu$X\Sigma^{-\frac{1}{2}}$

satu-satunya operasi yang dihitung n ( n - 1 ) / 2 kali adalah p perkalian danpenambahan 2 p (sebagai lawan dari p 2 + p perkalian dan p 2 + 2

$$D_{k\ell} = \sum_{i=1}^p (Q_{ki}-Q_{\ell i})^2.$$ $n(n-1)/2$$p$$2p$$p^2+p$$p^2+2p$penambahan dalam metode di atas), menghasilkan suatu algoritma yang dari urutan kompleksitas komputasi bukan O asli ( p 2 n 2 ) .$O(pn^2 + p^2n)$$O(p^2n^2)$

require(ICSNP) # for pair.diff(), C implementation

fastPwMahal = function(data) {

    # Calculate inverse square root matrix
    invCov = solve(cov(data))
    svds = svd(invCov)
    invCovSqr = svds$u %*% diag(sqrt(svds$d)) %*% t(svds$u)

    Q = data %*% invCovSqr

    # Calculate distances
    # pair.diff() calculates the n(n-1)/2 element-by-element
    # pairwise differences between each row of the input matrix
    sqrDiffs = pair.diff(Q)^2
    distVec = rowSums(sqrDiffs)

    # Create dist object without creating a n x n matrix
    attr(distVec, "Size") = nrow(data)
    attr(distVec, "Diag") = F
    attr(distVec, "Upper") = F
    class(distVec) = "dist"
    return(distVec)
}

Mari kita coba yang sudah jelas. Dari

$$D_{ij} = (x_i-x_j)^\prime \Sigma^{-1} (x_i-x_j)=x_i^\prime \Sigma^{-1}x_i + x_j^\prime \Sigma^{-1}x_j -2 x_i^\prime \Sigma^{-1}x_j$$

berikut ini kita dapat menghitung vektor

$$u_i = x_i^\prime \Sigma^{-1}x_i$$

dalam waktu dan matriks$O(p^2)$

$$V = X \Sigma^{-1} X^\prime$$

dalam waktu , kemungkinan besar menggunakan operasi larik cepat (paralel) yang built-in, dan kemudian membentuk solusi$O(p n^2 + p^2 n)$

$$D = u \oplus u - 2 V$$

di mana adalah produk luar sehubungan dengan + : ( a ⊕ b ) i j = a i + b j$\oplus$$+$$(a \oplus b)_{ij} = a_i + b_j.$

Sebuah Rimplementasi ringkas sejajar dengan formulasi matematis (dan mengasumsikan, dengan itu, bahwa sebenarnya dibalik dengan inverse ditulis h di sini):$\Sigma=\text{Var}(X)$$h$

mahal <- function(x, h=solve(var(x))) {
  u <- apply(x, 1, function(y) y %*% h %*% y)
  d <- outer(u, u, `+`) - 2 * x %*% h %*% t(x)
  d[lower.tri(d)]
}

Perhatikan, untuk kompatibilitas dengan solusi lain, bahwa hanya elemen off-diagonal unik yang dikembalikan, daripada seluruh matriks jarak kuadrat (simetris, nol-di-diagonal). Scatterplots menunjukkan hasilnya setuju dengan yang dari fastPwMahal.

Dalam C atau C ++, RAM dapat digunakan kembali dan dihitung dengan cepat, menghindarkan kebutuhan untuk penyimpanan menengah u ⊕ u .$u\oplus u$$u\oplus u$

Studi pengaturan waktu dengan mulai dari 33 hingga 5000 dan p mulai dari 10 hingga 100 menunjukkan implementasi ini 1,5 hingga 5 kali lebih cepat daripada dalam kisaran itu. Peningkatan menjadi lebih baik karena p dan n meningkat. Sebagai konsekuensinya, kita dapat mengharapkan menjadi lebih baik untuk p yang lebih kecil . Titik impas terjadi di sekitar p = 7 untuk n ≥ $n$$33$$5000$$p$$10$$100$$1.5$$5$fastPwMahal$p$$n$fastPwMahal$p$$p=7$$n\ge 100$. Apakah keunggulan komputasi yang sama dari solusi langsung ini berkaitan dengan implementasi lain mungkin merupakan masalah seberapa baik mereka mengambil keuntungan dari operasi array vektor.

Jika Anda ingin menghitung jarak sampel Mahalanobis, maka ada beberapa trik aljabar yang dapat Anda manfaatkan. Mereka semua mengarah pada penghitungan jarak Euclidean berpasangan, jadi mari kita asumsikan kita dapat menggunakannya dist()untuk itu. Biarkan menyatakan n × p matriks data, yang kita asumsikan akan terpusat sehingga bahwa kolom yang memiliki mean 0 dan memiliki peringkat p sehingga matriks kovarians sampel adalah nonsingular. (Pemusatan membutuhkan operasi O ( n p ) .) Kemudian matriks kovarian sampel adalah S = X T X / n $X$$n\times p$$p$$O(np)$

$$S = X^T X / n.$$

Sampel berpasangan jarak Mahalanobis dari adalah sama dengan jarak Euclidean berpasangan dari X L untuk setiap matriks L yang memenuhi L L T = S - 1 , misalnya akar kuadrat atau faktor Cholesky. Ini mengikuti dari beberapa aljabar linier dan itu mengarah ke suatu algoritma yang membutuhkan perhitungan S , S - 1 , dan dekomposisi Cholesky. Kompleksitas kasus terburuk adalah O ( n p 2 + p 3 ) .$X$

$$X L$$ $L$$LL^T = S^{-1}$$S$$S^{-1}$$O(np^2 + p^3)$

Lebih dalam, jarak ini berhubungan dengan jarak antara komponen utama sampel . Mari X = U D V T menyatakan SVD dari X . Kemudian S = V D 2 V T / n dan S - 1 / 2 = V D - 1 V T n 1 / 2 . Jadi X S - 1 / 2 = U V T n $X$$X=UDV^T$$X$

$$S=VD^2V^T/n$$ $$S^{-1/2}=VD^{-1}V^T n^{1/2}.$$ dan jarak sampel Mahalanobis hanyalah jarak Euclidean berpasangan dariU yangdiskalakan dengan faktor $$X S^{-1/2} = UV^T n^{1/2}$$ $U$ , karena jarak Euclidean adalah invarian rotasi. Ini mengarah ke suatu algoritma yang membutuhkan perhitungan SVDXyang memiliki kompleksitas kasus terburukO(np2)ketikan>p.$\sqrt{n}$$X$$O(n p^2)$$n>p$

Berikut ini adalah implementasi R dari metode kedua yang tidak dapat saya uji pada iPad yang saya gunakan untuk menulis jawaban ini.

u = svd(scale(x, center = TRUE, scale = FALSE), nv = 0)$u
dist(u)
# these distances need to be scaled by a factor of n

Ini adalah solusi yang jauh lebih ringkas. Itu masih didasarkan pada derivasi yang melibatkan matriks kovarians akar kuadrat terbalik (lihat jawaban saya yang lain untuk pertanyaan ini), tetapi hanya menggunakan basis R dan paket statistik. Tampaknya sedikit lebih cepat (sekitar 10% lebih cepat di beberapa tolok ukur yang saya jalankan). Perhatikan bahwa ia mengembalikan jarak Mahalanobis, yang bertentangan dengan jarak Maha kuadrat.

fastPwMahal = function(x1,invCovMat) {
  SQRT = with(svd(invCovMat), u %*% diag(d^0.5) %*% t(v))
  dist(x1 %*% SQRT)
}

Fungsi ini memerlukan matriks kovarians terbalik, dan tidak mengembalikan objek jarak - tetapi saya menduga bahwa versi fungsi ini akan lebih berguna untuk menumpuk pengguna pertukaran.

$n^2$

Jika Anda hanya menggunakan fitur-fitur Fortran77 di antarmuka, subrutin Anda masih cukup portabel untuk orang lain.

Ada cara yang sangat mudah untuk melakukannya menggunakan Paket R "biotools". Dalam hal ini Anda akan mendapatkan Matriks Mahalanobis Distance Squared.

#Manly (2004, p.65-66)

x1 <- c(131.37, 132.37, 134.47, 135.50, 136.17)
x2 <- c(133.60, 132.70, 133.80, 132.30, 130.33)
x3 <- c(99.17, 99.07, 96.03, 94.53, 93.50)
x4 <- c(50.53, 50.23, 50.57, 51.97, 51.37)

#size (n x p) #Means 
x <- cbind(x1, x2, x3, x4) 

#size (p x p) #Variances and Covariances
Cov <- matrix(c(21.112,0.038,0.078,2.01, 0.038,23.486,5.2,2.844, 
        0.078,5.2,24.18,1.134, 2.01,2.844,1.134,10.154), 4, 4)

library(biotools)
Mahalanobis_Distance<-D2.dist(x, Cov)
print(Mahalanobis_Distance)

Ini adalah kode yang diperluas dengan jawaban lama saya pindah ke sini dari utas lainnya .

Saya telah melakukan perhitungan waktu yang lama dari matriks simetris kuadrat dari jarak Mahalanobis berpasangan di SPSS melalui pendekatan matriks topi menggunakan penyelesaian sistem persamaan linear (untuk itu lebih cepat daripada membalikkan matriks kovarians).

Saya bukan pengguna R jadi saya baru saja mencoba mereproduksi @ahfoss ' resep ini di sini di SPSS bersama dengan resep "saya", pada data 1000 kasus dengan 400 variabel, dan saya menemukan cara saya jauh lebih cepat.

---

$\bf H$

$\mathbf{H}(n-1)$$\bf X(X'X)^{-1}X'$$\bf X$

Jadi, kolom tengah dari matriks data, hitung matriks topi, kalikan dengan (n-1), dan lakukan operasi yang berlawanan dengan pemusatan ganda. Anda mendapatkan matriks jarak Mahalanobis kuadrat.

$h$$h^2$$h_1h_2\cos$

Dalam pengaturan kami, matriks "double-centrate" secara khusus adalah matriks topi (dikalikan dengan n-1), bukan produk skalar euclidean, dan dengan demikian matriks jarak kuadrat yang dihasilkan adalah matriks jarak Mahalanobis kuadrat, bukan matriks jarak euclidean kuadrat.

$H$$\mathbf{H}(n-1)$H= {H,H,...}$\mathbf {D_{mahal}^2} = H+H'-2 \mathbf{H}(n-1)$

Kode dalam SPSS dan probe kecepatan di bawah ini.

---

Kode pertama ini sesuai dengan fungsi @ahfoss fastPwMahaldari jawaban yang dikutip . Ini setara dengan itu secara matematis. Tapi saya menghitung matriks simetris lengkap jarak (melalui operasi matriks) sementara @ahfoss menghitung segitiga matriks simetris (elemen demi elemen).

matrix. /*Matrix session in SPSS;
        /*note: * operator means matrix multiplication, &* means usual, elementwise multiplication.
get data. /*Dataset 1000 cases x 400 variables
!cov(data%cov). /*compute usual covariances between variables [this is my own matrix function].
comp icov= inv(cov). /*invert it
call svd(icov,u,s,v). /*svd
comp isqrcov= u*sqrt(s)*t(v). /*COV^(-1/2)
comp Q= data*isqrcov. /*Matrix Q (see ahfoss answer)
!seuclid(Q%m). /*Compute 1000x1000 matrix of squared euclidean distances;
               /*computed here from Q "data" they are the squared Mahalanobis distances.
/*print m. /*Done, print
end matrix.

Time elapsed: 3.25 sec

Berikut ini adalah modifikasi saya untuk membuatnya lebih cepat:

matrix.
get data.
!cov(data%cov).
/*comp icov= inv(cov). /*Don't invert.
call eigen(cov,v,s2). /*Do sdv or eigen decomposition (eigen is faster),
/*comp isqrcov= v * mdiag(1/sqrt(s2)) * t(v). /*compute 1/sqrt of the eigenvalues, and compose the matrix back, so we have COV^(-1/2).
comp isqrcov= v &* (make(nrow(cov),1,1) * t(1/sqrt(s2))) * t(v). /*Or this way not doing matrix multiplication on a diagonal matrix: a bit faster .
comp Q= data*isqrcov.
!seuclid(Q%m).
/*print m.
end matrix.

Time elapsed: 2.40 sec

$\bf X(X'X)^{-1}X'$$\bf (X'X)^{-1}X'$solve(X'X,X')

matrix.
get data.
!center(data%data). /*Center variables (columns).
comp hat= data*solve(sscp(data),t(data))*(nrow(data)-1). /*hat matrix, and multiply it by n-1 (i.e. by df of covariances).
comp ss= diag(hat)*make(1,ncol(hat),1). /*Now using its diagonal, the leverages (as column propagated into matrix).
comp m= ss+t(ss)-2*hat. /*compute matrix of squared Mahalanobis distances via "cosine rule".
/*print m.
end matrix.

[Notice that if in "comp ss" and "comp m" lines you use "sscp(t(data))",
 that is, DATA*t(DATA), in place of "hat", you get usual sq. 
 euclidean distances]

Time elapsed: 0.95 sec

Rumus yang Anda poskan bukan menghitung apa yang Anda pikir Anda hitung (statistik-U).

Dalam kode yang saya posting, saya menggunakan cov(x1)scaling matrix (ini adalah varian dari perbedaan data berpasangan). Anda menggunakan cov(x0)(ini adalah matriks kovarians dari data asli Anda). Saya pikir ini adalah kesalahan Anda. Inti dari menggunakan perbedaan berpasangan adalah bahwa hal itu membebaskan Anda dari asumsi bahwa distribusi multivariat data Anda simetris di sekitar pusat simetri (atau harus memperkirakan pusat simetri dalam hal ini, karena crossprod(x1)sebanding dengan cov(x1)). Jelas, dengan menggunakan cov(x0)Anda kehilangan itu.

Ini dijelaskan dengan baik dalam makalah yang saya tautkan dalam jawaban asli saya.