Büyük, seyrek bir matris üzerinde boyutsallık azaltma (SVD veya PCA)

/ edit: Şimdi daha fazla takip irlba :: prcomp_irlba kullanabilirsiniz

/ edit: kendi gönderimde takip etmek. irlbaŞimdi, temel bileşenleri hesaplamak için kullanmanıza izin veren "merkez" ve "ölçek" argümanlarına sahiptir, örneğin:

pc <- M %*% irlba(M, nv=5, nu=0, center=colMeans(M), right_only=TRUE)$v

Büyük bir seyrek var Matrixben öğrenme algoritması bir makinede kullanmak istiyorum özelliklerinden:

library(Matrix)
set.seed(42)
rows <- 500000
cols <- 10000
i <- unlist(lapply(1:rows, function(i) rep(i, sample(1:5,1))))
j <- sample(1:cols, length(i), replace=TRUE)
M <- sparseMatrix(i, j)

Bu matrisin birçok sütunu olduğu için, boyutluluğunu daha yönetilebilir bir şeye düşürmek istiyorum. Mükemmel irlba paketini SVD yapmak ve ilk n ana bileşenlerini döndürmek için kullanabilirim (burada 5; gerçek veri setimde muhtemelen 100 veya 500 kullanacağım):

library(irlba)
pc <- irlba(M, nu=5)$u

Ancak, PCA'yı gerçekleştirmeden önce birinin matrisi ortalaması gerektiğini okudum (sütun ortalamasını her bir sütundan çıkarın). Bunu veri setimde yapmak çok zor ve ayrıca matrisin azlığını da mahveder.

Ölçeklendirilmemiş verilerde SVD gerçekleştirmek ve doğrudan bir makine öğrenme algoritmasına beslemek ne kadar "kötü"? Matrisin azlığını koruyarak bu verileri ölçeklendirmenin etkili yolları var mı?

/ edit: B_miner tarafından dikkatimi çekti, "PC'ler" gerçekten olmalı:

pc <- M %*% irlba(M, nv=5, nu=0)$v 

Ayrıca, whuber'in cevabının crossprod, seyrek matrislerde son derece hızlı olan fonksiyonu aracılığıyla uygulanması oldukça kolay olmalı :

system.time(M_Mt <- crossprod(M)) # 0.463 seconds
system.time(means <- colMeans(M)) #0.003 seconds

Şimdi meansçıkarmadan önce vektöre ne yapacağımdan emin değilim M_Mt, ancak çözdüğümde yayınlayacağım.

/ edit3: İşte işlemin her aşaması için seyrek matris işlemleri kullanan, whuber kodunun değiştirilmiş hali. Eğer siz bellekte tüm seyrek matris saklayabilir, çok hızlı bir şekilde çalışır:

library('Matrix')
library('irlba')
set.seed(42)
m <- 500000
n <- 100
i <- unlist(lapply(1:m, function(i) rep(i, sample(25:50,1))))
j <- sample(1:n, length(i), replace=TRUE)
x <- sparseMatrix(i, j, x=runif(length(i)))

n_comp <- 50
system.time({
  xt.x <- crossprod(x)
  x.means <- colMeans(x)
  xt.x <- (xt.x - m * tcrossprod(x.means)) / (m-1)
  svd.0 <- irlba(xt.x, nu=0, nv=n_comp, tol=1e-10)
})
#user  system elapsed 
#0.148   0.030   2.923 

system.time(pca <- prcomp(x, center=TRUE))
#user  system elapsed 
#32.178   2.702  12.322

max(abs(pca$center - x.means))
max(abs(xt.x - cov(as.matrix(x))))
max(abs(abs(svd.0$v / pca$rotation[,1:n_comp]) - 1))

Sütun sayısını 10.000'e, asıl bileşenlerin sayısını 25'e ayarlarsanız, irlbatabanlı PCA'nın yaklaşık 50 ana bileşeni hesaplaması yaklaşık 17 dakika sürer ve yaklaşık 6 GB RAM kullanır, bu da çok da kötü değildir.

Her şeyden önce, verileri gerçekten merkezlemek istersiniz . Değilse, PCA geometrik yorumu gösterileri birinci temel bileşen yakın araçlarının vektöre olacağını ve sonraki tüm PC'ler yakın ilk vektöre olmak olur herhangi PC'ler yaklaşan engel olan, buna dik olacaktır. Daha sonraki bilgisayarların çoğunun yaklaşık olarak doğru olacağını ümit edebiliriz, ancak ilk birkaç PC'nin - en önemlisi - oldukça yanlış olacağı durumlarda, bunun değeri sorgulanabilir.

Peki ne yapmalı? PCA, matrisinin tekil değer ayrışması yoluyla ilerler . Esansiyel bilgiler içerdiği edilecektir X X $X$$X X'$ bu durumda bir olduğunu, ile 10000 matris: o yönetilebilir olabilir. Hesaplaması, bir diğeriyle bir sütunun yaklaşık 50 milyon nokta ürününün hesaplanmasını içerir.$10000$$10000$

İki sütunu düşünün, o zaman, ve Z (her biri bir 500000 -vector; bu boyut n olsun ). Ortalamaları sırasıyla m Y ve m Z olsun . Ne istediğiniz bilgi işlem yazma, olduğu $Y$$Z$$500000$$n$$m_Y$$m_Z$$\mathbf{1}$ için ait -vector 1 's,$n$$1$

çünkü ve m Z = 1 ⋅ Z / n .$m_Y = \mathbf{1}\cdot Y / n$$m_Z = \mathbf{1}\cdot Z/n$

Bu , girişleri Y ⋅ Z değerlerini sağlayan comp ' ı hesaplamak için seyrek matris tekniklerini kullanmanıza ve ardından 10000 sütun aracını temel alarak katsayılarını ayarlamanıza olanak tanır . Ayarlama zarar vermemelidir, çünkü X X ′ çok seyrek olacak gibi görünmüyor .$X X'$$Y\cdot Z$$10000$$X X'$

Örnek

Aşağıdaki Rkod bu yaklaşımı göstermektedir. get.colPratikte harici bir veri kaynağından bir seferde bir sütunu okuyabilen ve böylece gerekli RAM miktarını azaltan (tabii ki hesaplama hızında bir miktar maliyet) bir saplama kullanır . PCA'yı iki şekilde hesaplar: önceki yapıya uygulanan SVD yoluyla ve doğrudan kullanma . Daha sonra iki yaklaşımın çıktısını karşılaştırır. Hesaplama süresi 100 sütun için yaklaşık 50 saniyedir ve yaklaşık dörtlü ölçeklenir: 10K'lık bir 10K matrisinde SVD yaparken beklemeye hazır olun!$X$prcomp

m <- 500000 # Will be 500,000
n <- 100    # will be 10,000
library("Matrix")
x <- as(matrix(pmax(0,rnorm(m*n, mean=-2)), nrow=m), "sparseMatrix")
#
# Compute centered version of x'x by having at most two columns
# of x in memory at any time.
#
get.col <- function(i) x[,i] # Emulates reading a column
system.time({
  xt.x <- matrix(numeric(), n, n)
  x.means <- rep(numeric(), n)
  for (i in 1:n) {
    i.col <- get.col(i)
    x.means[i] <- mean(i.col)
    xt.x[i,i] <- sum(i.col * i.col)
    if (i < n) {
      for (j in (i+1):n) {
        j.col <- get.col(j)
        xt.x[i,j] <- xt.x[j,i] <- sum(j.col * i.col)
      }    
    }
  }
  xt.x <- (xt.x - m * outer(x.means, x.means, `*`)) / (m-1)
  svd.0 <- svd(xt.x / m)
}
)
system.time(pca <- prcomp(x, center=TRUE))
#
# Checks: all should be essentially zero.
#
max(abs(pca$center - x.means))
max(abs(xt.x - cov(x)))
max(abs(abs(svd.0$v / pca$rotation) - 1)) # (This is an unstable calculation.)