Önyükleme veya Monte Carlo yaklaşımı kullanılarak önemli ana bileşenler nasıl belirlenir?

Temel Bileşen Analizi (PCA) veya Ampirik Ortogonal İşlev (EOF) Analizinden çıkan önemli kalıpların sayısını belirlemekle ilgileniyorum. Özellikle bu yöntemi iklim verilerine uygulamakla ilgileniyorum. Veri alanı, M'nin zaman boyutu (örneğin günler) ve N'nin uzaysal boyut (örneğin, lon / lat konumları) olduğu bir MxN matrisidir. Önemli bilgisayarları belirlemek için olası bir önyükleme yöntemini okudum, ancak daha ayrıntılı bir açıklama bulamadım. Şimdiye dek, bu kesiti belirlemek için Kuzey'in Kuralını (Kuzey ve ark ., 1982) uygulamıştım, ancak daha sağlam bir yöntem olup olmadığını merak ediyordum.

Örnek olarak:

###Generate data
x <- -10:10
y <- -10:10
grd <- expand.grid(x=x, y=y)

#3 spatial patterns
sp1 <- grd$x^3+grd$y^2
tmp1 <- matrix(sp1, length(x), length(y))
image(x,y,tmp1)

sp2 <- grd$x^2+grd$y^2
tmp2 <- matrix(sp2, length(x), length(y))
image(x,y,tmp2)

sp3 <- 10*grd$y
tmp3 <- matrix(sp3, length(x), length(y))
image(x,y,tmp3)


#3 respective temporal patterns
T <- 1:1000

tp1 <- scale(sin(seq(0,5*pi,,length(T))))
plot(tp1, t="l")

tp2 <- scale(sin(seq(0,3*pi,,length(T))) + cos(seq(1,6*pi,,length(T))))
plot(tp2, t="l")

tp3 <- scale(sin(seq(0,pi,,length(T))) - 0.2*cos(seq(1,10*pi,,length(T))))
plot(tp3, t="l")


#make data field - time series for each spatial grid (spatial pattern multiplied by temporal pattern plus error)
set.seed(1)
F <- as.matrix(tp1) %*% t(as.matrix(sp1)) + 
as.matrix(tp2) %*% t(as.matrix(sp2)) + 
as.matrix(tp3) %*% t(as.matrix(sp3)) +
matrix(rnorm(length(T)*dim(grd)[1], mean=0, sd=200), nrow=length(T), ncol=dim(grd)[1]) # error term

dim(F)
image(F)


###Empirical Orthogonal Function (EOF) Analysis 
#scale field
Fsc <- scale(F, center=TRUE, scale=FALSE)

#make covariance matrix
C <- cov(Fsc)
image(C)

#Eigen decomposition
E <- eigen(C)

#EOFs (U) and associated Lambda (L) 
U <- E$vectors
L <- E$values

#projection of data onto EOFs (U) to derive principle components (A)
A <- Fsc %*% U

dim(U)
dim(A)

#plot of top 10 Lambda
plot(L[1:10], log="y")

#plot of explained variance (explvar, %) by each EOF
explvar <- L/sum(L) * 100
plot(explvar[1:20], log="y")


#plot original patterns versus those identified by EOF
layout(matrix(1:12, nrow=4, ncol=3, byrow=TRUE), widths=c(1,1,1), heights=c(1,0.5,1,0.5))
layout.show(12)

par(mar=c(4,4,3,1))
image(tmp1, main="pattern 1")
image(tmp2, main="pattern 2")
image(tmp3, main="pattern 3")

par(mar=c(4,4,0,1)) 
plot(T, tp1, t="l", xlab="", ylab="")
plot(T, tp2, t="l", xlab="", ylab="")
plot(T, tp3, t="l", xlab="", ylab="")

par(mar=c(4,4,3,1))
image(matrix(U[,1], length(x), length(y)), main="eof 1") 
image(matrix(U[,2], length(x), length(y)), main="eof 2")
image(matrix(U[,3], length(x), length(y)), main="eof 3")

par(mar=c(4,4,0,1)) 
plot(T, A[,1], t="l", xlab="", ylab="")
plot(T, A[,2], t="l", xlab="", ylab="")
plot(T, A[,3], t="l", xlab="", ylab="")

Ve işte PC'nin önemini belirlemek için kullandığım yöntem. Temel olarak, temel kural, komşu Lambdalar arasındaki farkın, ilişkili hatalarından daha büyük olması gerektiğidir.

###Determine significant EOFs

#North's Rule of Thumb
Lambda_err <- sqrt(2/dim(F)[2])*L
upper.lim <- L+Lambda_err
lower.lim <- L-Lambda_err
NORTHok=0*L
for(i in seq(L)){
    Lambdas <- L
    Lambdas[i] <- NaN
    nearest <- which.min(abs(L[i]-Lambdas))
    if(nearest > i){
        if(lower.lim[i] > upper.lim[nearest]) NORTHok[i] <- 1
    }
    if(nearest < i){
        if(upper.lim[i] < lower.lim[nearest]) NORTHok[i] <- 1
    }
}
n_sig <- min(which(NORTHok==0))-1

plot(L[1:10],log="y", ylab="Lambda (dots) and error (vertical lines)", xlab="EOF")
segments(x0=seq(L), y0=L-Lambda_err, x1=seq(L), y1=L+Lambda_err)
abline(v=n_sig+0.5, col=2, lty=2)
text(x=n_sig, y=mean(L[1:10]), labels="North's Rule of Thumb", srt=90, col=2)

Björnsson ve Venegas ( 1997 ) tarafından anlamlılık testlerinde yardımcı olacak bölüm bölümünü buldum - bunlar baskın varyans tipinin muhtemelen kullanmayı umduğum gibi olduğu üç test kategorisine atıfta bulunuyorlar . Zaman boyutunun karıştırılması ve Lambdasların birçok permütasyon üzerinde yeniden hesaplanması için bir tür Monte Carlo yaklaşımı. von Storch ve Zweiers (1999) Lambda spektrumunu referans "gürültü" spektrumuyla karşılaştıran bir teste de atıfta bulunur. Her iki durumda da, bunun nasıl yapılabileceğinden ve permütasyonlar tarafından belirlenen güven aralıkları verildiğinde önem testinin nasıl yapıldığından emin değilim.

Yardımınız için teşekkürler.

Kaynaklar: Björnsson, H. ve Venegas, SA (1997). "İklim verilerinin EOF ve SVD analizleri için bir el kitabı", McGill Üniversitesi, CCGCR Rapor No. 97-1, Montréal, Québec, 52pp. http://andvari.vedur.is/%7Efolk/halldor/PICKUP/eof.pdf

GR Kuzey, TL Bell, RF Cahalan ve FJ Moeng. (1982). Ampirik ortogonal fonksiyonların kestirimindeki örnekleme hataları. Pzt Wea. Rev., 110: 699-706.

Storch, H, Zwiers, FW (1999). İklim araştırmalarında istatistiksel analiz. Cambridge Üniversitesi Basını.

Bu benim sorum olsa bile, buradaki diyaloğu biraz ilerletmeye çalışacağım. Bunu sorduğumdan bu yana 6 ay geçti ve maalesef tam bir cevap verilmedi, şu ana kadar ne topladığımı özetlemeye çalışacağım ve birisinin kalan meseleler üzerinde ayrıntılı bilgi sahibi olup olamayacağını göreceğim. Lütfen uzun cevap için özür dilerim, ama başka bir yol göremiyorum ...

İlk önce, muhtemelen daha iyi bir sentetik veri seti kullanarak birkaç yaklaşım göstereceğim. Gappy verileri üzerinde EOF yürütmek için bir algoritma kullanımını gösteren Beckers ve Rixon ( 2003 ) tarafından yazılmış bir makaleden gelir . Kimse ilgilenirse algoritmasını R de kopyaladım ( link ).

Sentetik veri seti:

#color palette
pal <- colorRampPalette(c("blue", "cyan", "yellow", "red"))

#Generate data
m=50
n=100
frac.gaps <- 0.5 # the fraction of data with NaNs
N.S.ratio <- 0.25 # the Noise to Signal ratio for adding noise to data

x <- (seq(m)*2*pi)/m
t <- (seq(n)*2*pi)/n


#True field
Xt <- 
 outer(sin(x), sin(t)) + 
 outer(sin(2.1*x), sin(2.1*t)) + 
 outer(sin(3.1*x), sin(3.1*t)) +
 outer(tanh(x), cos(t)) + 
 outer(tanh(2*x), cos(2.1*t)) + 
 outer(tanh(4*x), cos(0.1*t)) + 
 outer(tanh(2.4*x), cos(1.1*t)) + 
 tanh(outer(x, t, FUN="+")) + 
 tanh(outer(x, 2*t, FUN="+"))

Xt <- t(Xt)
image(Xt, col=pal(100))

#Noise field
set.seed(1)
RAND <- matrix(runif(length(Xt), min=-1, max=1), nrow=nrow(Xt), ncol=ncol(Xt))
R <- RAND * N.S.ratio * Xt

#True field + Noise field
Xp <- Xt + R
image(Xp, col=pal(100))

Dolayısıyla, gerçek veri alanı Xt9 sinyalden oluşur ve Xpaşağıdaki örneklerde kullanılacak olan gözlemlenen alanı oluşturmak için buna biraz gürültü ekledim . EOF'ler şu şekilde belirlenir:

EOF

#make covariance matrix
C <- t(Xp) %*% Xp #cov(Xp)
image(C)

#Eigen decomposition
E <- svd(C)

#EOFs (U) and associated Lambda (L) 
U <- E$u
L <- E$d

#projection of data onto EOFs (U) to derive principle components (A)
A <- Xp %*% U

Orijinal örneğimde kullandığım örneği takip ederek, North'un kuralı üzerinden "önemli" EOF'ler belirleyeceğim.

Kuzey'in Kural Kuralı

Lambda_err <- sqrt(2/dim(Xp)[2])*L
upper.lim <- L+Lambda_err
lower.lim <- L-Lambda_err
NORTHok=0*L
for(i in seq(L)){
    Lambdas <- L
    Lambdas[i] <- NaN
    nearest <- which.min(abs(L[i]-Lambdas))
    if(nearest > i){
        if(lower.lim[i] > upper.lim[nearest]) NORTHok[i] <- 1
    }
    if(nearest < i){
        if(upper.lim[i] < lower.lim[nearest]) NORTHok[i] <- 1
    }
}
n_sig <- min(which(NORTHok==0))-1
n_sig

plot(L[1:20],log="y", ylab="Lambda (dots) and error (vertical lines)", xlab="EOF")
segments(x0=seq(L), y0=L-Lambda_err, x1=seq(L), y1=L+Lambda_err)
abline(v=n_sig+0.5, col=2, lty=2)
text(x=n_sig, y=mean(L[1:10]), labels="North's Rule of Thumb", srt=90, col=2)

2: 4'lük Lambda değerleri, genlikte birbirlerine çok yakın oldukları için, bunlar kural kuralına göre önemsiz sayılır - yani ilgili EOF desenleri benzer genliklerini vererek üst üste gelebilir ve karışabilir. Bu alanda 9 sinyalin var olduğunu bildiğimize göre bu talihsizlik.

Daha sübjektif bir yaklaşım, log-dönüştürülmüş Lambda değerlerini ("Scree plot") görüntülemek ve ardından izleyen değerlere bir gerileme sağlamaktır. Biri, lambda değerlerinin bu çizginin üzerinde hangi seviyede bulunduğunu görsel olarak belirleyebilir:

Kayşat arsa

ntrail <- 35
tail(L, ntrail)
fit <- lm(log(tail(L, ntrail)) ~ seq(length(L)-ntrail+1, length(L)))
plot(log(L))
abline(fit, col=2)

Dolayısıyla, 5 lider EOF bu çizginin üzerinde yer almaktadır. XpEk bir gürültü eklenmediğinde ve sonuçları 9 orijinal sinyali de gösterdiğinde bu örneği denedim . Bu nedenle, EOF 6: 9'un önemsizliği, kendi genliklerinin sahadaki gürültüden daha düşük olması nedeniyledir.

Daha nesnel bir yöntem ise Overland ve Preisendorfer (1982) 'in "Kural N" kriterleridir. wqPaket içinde aşağıda gösterdiğim bir uygulama var .

Kural N

library(wq)
eofNum(Xp, distr = "normal", reps = 99)

RN <- ruleN(nrow(Xp), ncol(Xp), type = "normal", reps = 99)
RN
eigs <- svd(cov(Xp))$d
plot(eigs, log="y")
lines(RN, col=2, lty=2)

Kural N, 4 önemli EOF tanımladı. Şahsen, bu yöntemi daha iyi anlamam gerekiyor; Neden aynı dağılımı kullanmayan rasgele bir alana dayanarak hata seviyesini ölçmek mümkün Xp? Bu metottaki bir varyasyon, Xpher kolonun rastgele olarak yeniden karıştırılması için verileri yeniden örneklemektir . Bu şekilde, rastgele alanın toplam varyansının aynı olmasını sağlarız Xp. Birçok kez yeniden örnekleyerek, ayrıştırmanın temel hatasını hesaplayabiliriz.

Rastgele alana sahip Monte Carlo (yani Null model karşılaştırması)

iter <- 499
LAMBDA <- matrix(NaN, ncol=iter, nrow=dim(Xp)[2])

set.seed(1)
for(i in seq(iter)){
    #i=1

    #random reorganize dimensions of scaled field
    Xp.tmp <- NaN*Xp
    for(j in seq(dim(Xp.tmp)[2])){
        #j=1
        Xp.tmp[,j] <- Xp[,j][sample(nrow(Xp))]
    }

    #make covariance matrix
    C.tmp <- t(Xp.tmp) %*% Xp.tmp #cov(Xp.tmp)

    #SVD decomposition
    E.tmp <- svd(C.tmp)

    #record Lambda (L) 
    LAMBDA[,i] <- E.tmp$d

    print(paste(round(i/iter*100), "%", " completed", sep=""))
}

boxplot(t(LAMBDA), log="y", col=8, border=2, outpch="")
points(L)

Yine, 4 EOF rastgele alanlar için dağılımların üstündedir. Bu yaklaşıma ve Kural N'ye olan endişem, bunların Lambda değerlerinin güven aralıklarını tam olarak ele almamaları; Örneğin, yüksek bir ilk Lambda değeri otomatik olarak izleyenler tarafından açıklanacak daha düşük bir varyans miktarı ile sonuçlanacaktır. Bu nedenle, rastgele alanlardan hesaplanan Lambda her zaman daha az dik bir eğime sahip olacak ve çok az önemli EOF seçilmesine neden olabilir. [NOT: eofNum()İşlev, EOF'lerin bir korelasyon matrisinden hesaplandığını varsayar. Bu sayı, örneğin bir kovaryans matrisinin kullanılması durumunda farklı olabilir (ortalanmış fakat ölçeklendirilmemiş veri).

Son olarak, @ tomasz74, Babamoradi ve ark. (2013), kısaca baktım. Çok ilginç, ancak Lambda'dan ziyade EOF yükleri ve katsayıları CI'lerini hesaplamaya odaklanmış gibi görünüyor. Bununla birlikte, aynı yöntemi kullanarak Lambda hatasını değerlendirmenin benimsenebileceğine inanıyorum. Yeni bir alan üretilinceye kadar satırları yeniden örnekleyerek veri alanının önyüklemesi yeniden örnekleme yapılır. Aynı satır, birden fazla kez yeniden örneklenebilir, bu parametrik olmayan bir yaklaşımdır ve birinin veri dağıtımı hakkında varsayımlarda bulunması gerekmez.

Lambda değerlerinin önyüklemesi

B <- 40 * nrow(Xp)
LAMBDA <- matrix(NaN, nrow=length(L), ncol=B)
for(b in seq(B)){
    samp.b <- NaN*seq(nrow(Xp))
    for(i in seq(nrow(Xp))){
        samp.b[i] <- sample(nrow(Xp), 1)
    }
    Xp.b  <- Xp[samp.b,]
    C.b  <- t(Xp.b) %*% Xp.b 
    E.b  <- svd(C.b)
    LAMBDA[,b] <- E.b$d
    print(paste(round(b/B*100), "%", " completed", sep=""))
}
boxplot(t(LAMBDA), log="y", col=8, outpch="", ylab="Lambda [log-scale]")
points(L, col=4)
legend("topright", legend=c("Original"), pch=1, col=4)

Her ne kadar bu, Lambda değerlerinin hatasını hesaplamak için Kuzey'in kurallarından daha güçlü olsa da, artık EOF'un önemi sorusunun bunun ne anlama geldiğine dair farklı fikirlere indiğine inanıyorum. Kuzeyin başparmak ve önyükleme yöntemleri kuralı için, önem, terasında Lambda değerleri arasında çakışma olup olmamasına bağlı olarak daha belirgin görünüyor. Varsa, bu EOF'ler sinyallerinde karıştırılabilir ve "gerçek" modelleri temsil etmez. Öte yandan, bu iki EOF belirgin bir miktar sapmayı tanımlayabilir (rastgele bir alanın ayrışmasına kıyasla - örneğin Kural N). Bu nedenle eğer biri gürültüyü filtrelemekle (EOF kesmesi ile) ilgileniyorsa, Kural N yeterli olacaktır. Bir veri setinde gerçek kalıpları belirlemekle ilgileniyorsanız, Lambda örtüşmesinin daha katı kriterleri daha sağlam olabilir.

Yine, bu konularda uzman değilim, bu yüzden daha fazla deneyime sahip birisinin bu açıklamaya ekleyebileceğini umuyorum.

Referanslar:

Beckers, Jean-Marie ve M. Rixen. "EOF Hesaplamaları ve Eksik Oşinografik Veri Kümelerinden Veri Doldurma." Atmosferik ve Okyanus Teknolojisi Dergisi 20.12 (2003): 1839-1856.

Overland, J. ve R. Preisendorfer, Bir siklon klimatolojisine uygulanan ana bileşenler için bir anlamlılık testi, Mon. Wea. Rev., 110, 1-4, 1982.