पदानुक्रमित रैखिक प्रतिगमन करने के लिए मानक एल्गोरिदम?

Question

क्या पदानुक्रमित रैखिक प्रतिगमन करने के लिए मानक एल्गोरिदम (कार्यक्रमों के विपरीत) हैं? क्या लोग आमतौर पर सिर्फ MCMC करते हैं या फिर अधिक विशिष्ट, शायद आंशिक रूप से बंद किए गए, एल्गोरिदम हैं?

Answer 1

एक के लिए हार्वे गोल्डस्टीन के पुनरावृत्त सामान्यीकृत न्यूनतम-वर्ग (IGLS) एल्गोरिथ्म है, और यह भी मामूली संशोधन है, प्रतिबंधित पुनरावृत्त सामान्यीकृत न्यूनतम-वर्ग (RIGLS), जो कि भिन्न मापदंडों का निष्पक्ष अनुमान देता है।

ये एल्गोरिदम अभी भी पुनरावृत्त हैं, इसलिए इसे बंद नहीं किया गया है, लेकिन वे MCMC या अधिकतम संभावना से कम्प्यूटेशनल रूप से सरल हैं। आप केवल तब तक पुनरावृति करते हैं जब तक कि पैरामीटर परिवर्तित नहीं हो जाते।

• गोल्डस्टीन एच। बहुस्तरीय मिश्रित रैखिक-मॉडल विश्लेषण Iterative Generalized Least-Squares का उपयोग करते हुए। बायोमेट्रिक 1986; 73 (1): 43-56। doi: 10.1093 / बायोमेट्रिक / 73.1.43

• गोल्डस्टीन एच। प्रतिबंधित निष्पक्ष धमनीकृत सामान्यीकृत खमीर-वर्ग अनुमान। बायोमेट्रिक 1989; 76 (3): 622-623। doi: 10.1093 / बायोमेट्रिक / 76.3.622

इस और विकल्पों के बारे में अधिक जानकारी के लिए, देखें:

• स्टीफन डब्ल्यू। राउडेनबश, एंथनी एस। ब्रिक। पदानुक्रमित रैखिक मॉडल: अनुप्रयोग और डेटा विश्लेषण विधियाँ । (द्वितीय संस्करण) ऋषि, २००२।

Comments

शानदार! ठीक वही जो मेरे द्वारा खोजा जा रहा था।

— जॉन साल्वेटियर

Answer 2

R में lme4 पैकेज पुनरावृत्त कम से कम वर्गों (IRLS) का उपयोग करता है और पुनरावृत्त पुनरावृत्त कम से कम वर्ग (PIRLS) का उपयोग करता है। PDF यहाँ देखें:

http://rss.acs.unt.edu/Rdoc/library/lme4/doc/index.html

Comments

डगलस बेट्स और स्टीवन वॉकर ने एक GitHub प्रोजेक्ट बनाया है जिसका लक्ष्य उपरोक्त PIRLS एल्गोरिदम को लागू करने के लिए शुद्ध आर कोड का उपयोग करना है। github.com/lme4/lme4pureR । यदि आप R lmer()के lme4पैकेज में बेस फंक्शन पर विचार करते हैं, तो आपको आमतौर पर C ++ कोड के एक पूरे समूह के माध्यम से पढ़ना होगा। PIRLS के कार्यान्वयन को समझें lmer()(जो कि हम में से उन लोगों के लिए चुनौतीपूर्ण हो सकता है जो C ++ प्रोग्रामिंग में पारंगत नहीं हैं)।

— क्रिस

Answer 3

HLM के लिए "कंप्यूटिंग एल्गोरिदम" के लिए एक और अच्छा स्रोत (हद तक कि आप उन्हें LMM के समान विनिर्देशों के रूप में देखते हैं) होगा:

• मैककुलोच, सी।, सियरल, एस।, न्यूरोहास, जे। (2008)। सामान्यीकृत रैखिक और मिश्रित मॉडल। द्वितीय संस्करण। विले। अध्याय 14 - कम्प्यूटिंग।

एलएमएम की गणना के लिए उनके द्वारा सूचीबद्ध एल्गोरिदम में शामिल हैं:

• EM एल्गोरिथ्म
• न्यूटन रफसन एल्गोरिथ्म

एल्गोरिदम वे GLMM की सूची में शामिल हैं:

• संख्यात्मक चतुर्भुज (GH क्वाडरेचर)
• EM एल्गोरिथ्म
• MCMC एल्गोरिदम (जैसा कि आप उल्लेख करते हैं)
• स्टोचस्टिक सन्निकटन एल्गोरिदम
• अधिकतम संभावना का अनुकरण किया

GLMM के लिए अन्य एल्गोरिदम है कि वे सुझाव शामिल हैं:

• दंडित अर्ध-संभावना विधि
• लाप्लास सन्निकटन
• बूटस्ट्रैप पूर्वाग्रह सुधार के साथ PQL / लाप्लास

Answer 4

यदि आप HLM को एक प्रकार का रैखिक मिश्रित मॉडल मानते हैं, तो आप EM एल्गोरिथ्म पर विचार कर सकते हैं। निम्नलिखित पाठ्यक्रम नोटों के पृष्ठ 22-23 में बताया गया है कि मिश्रित मॉडल के लिए क्लासिक EM एल्गोरिथ्म को कैसे लागू किया जाए:

http://www.stat.ucla.edu/~yuille/courses/stat153/emtutorial.pdf

###########################################################
#     Classical EM algorithm for Linear  Mixed Model      #
###########################################################
em.mixed <- function(y, x, z, beta, var0, var1,maxiter=2000,tolerance = 1e-0010)
    {
    time <-proc.time()
    n <- nrow(y)
    q1 <- nrow(z)
    conv <- 1
    L0 <- loglike(y, x, z, beta, var0, var1)
    i<-0
    cat("  Iter.       sigma0                 sigma1        Likelihood",fill=T)
    repeat {
            if(i>maxiter) {conv<-0
                    break}
    V <- c(var1) * z %*% t(z) + c(var0) * diag(n)
    Vinv <- solve(V)
    xb <- x %*% beta
    resid <- (y-xb)
    temp1 <- Vinv %*% resid
    s0 <- c(var0)^2 * t(temp1)%*%temp1 + c(var0) * n - c(var0)^2 * tr(Vinv)
    s1 <- c(var1)^2 * t(temp1)%*%z%*%t(z)%*%temp1+ c(var1)*q1 -
                                                c(var1)^2 *tr(t(z)%*%Vinv%*%z)
    w <- xb + c(var0) * temp1
    var0 <- s0/n
    var1 <- s1/q1
    beta <- ginverse( t(x) %*% x) %*% t(x)%*% w
    L1 <- loglike(y, x, z, beta, var0, var1)
    if(L1 < L0) { print("log-likelihood must increase, llikel <llikeO, break.")
                             conv <- 0
break
}
    i <- i + 1
    cat("  ", i,"  ",var0,"  ",var1,"  ",L1,fill=T)
    if(abs(L1 - L0) < tolerance) {break}  #check for convergence
    L0 <- L1
    }
list(beta=beta, var0=var0,var1=var1,Loglikelihood=L0)
}

#########################################################
#  loglike calculates the LogLikelihood for Mixed Model #
#########################################################
loglike<- function(y, x, z, beta, var0, var1)
}
{
n<- nrow(y)
V <- c(var1) * z %*% t(z) + c(var0) * diag(n)
Vinv <- ginverse(V)
xb <- x %*% beta
resid <- (y-xb)
temp1 <- Vinv %*% resid
(-.5)*( log(det(V)) + t(resid) %*% temp1 )
}