क्रमिक लॉजिस्टिक प्रतिगमन के लिए शक्ति विश्लेषण

Question

मैं एक कार्यक्रम (आर या एसएएस या स्टैंडअलोन में, अगर मुफ्त या कम लागत) की तलाश कर रहा हूं जो कि ऑर्डिनल लॉजिस्टिक रिग्रेशन के लिए शक्ति विश्लेषण करेगा।

Answer 1

मैं सिमुलेशन द्वारा मूल बातों से परे शक्ति विश्लेषण करना पसंद करता हूं। पहले से तैयार किए गए पैकेजों के साथ, मैं कभी भी निश्चित नहीं हूं कि क्या धारणाएं बन रही हैं।

आर का उपयोग करके बिजली के लिए अनुकरण करना बहुत सीधे आगे (और सस्ती) है।

1. तय करें कि आपको क्या लगता है कि आपका डेटा कैसा दिखना चाहिए और आप इसका विश्लेषण कैसे करेंगे
2. एक फ़ंक्शन या अभिव्यक्तियों को सेट करें जो किसी दिए गए रिश्ते और नमूना आकार के लिए डेटा का अनुकरण करेंगे और विश्लेषण करेंगे (एक फ़ंक्शन बेहतर है जिसमें आप नमूना आकार और मापदंडों को विभिन्न मूल्यों को आज़माने के लिए तर्कों में बना सकते हैं)। फ़ंक्शन या कोड को पी-मूल्य या अन्य परीक्षण सांख्यिकीय वापस करना चाहिए।
3. replicateएक बार के ऊपर से कोड चलाने के लिए फ़ंक्शन का उपयोग करें (मैं आमतौर पर लगभग 100 बार शुरू करता हूं यह महसूस करने के लिए कि कितना समय लगता है और सही सामान्य क्षेत्र प्राप्त करने के लिए, फिर इसे 1,000 तक और कभी-कभी 10,000 या 100,000 तक अंतिम मान जो मैं उपयोग करूंगा)। उस समय का अनुपात जिसे आपने अशक्त परिकल्पना को खारिज कर दिया, वह शक्ति है।
4. शर्तों के एक और सेट के लिए ऊपर फिर से करें।

यहाँ एक साधारण उदाहरण है, जो आंत्रेतर प्रतिगमन के साथ है:

library(rms)

tmpfun <- function(n, beta0, beta1, beta2) {
    x <- runif(n, 0, 10)
    eta1 <- beta0 + beta1*x
    eta2 <- eta1 + beta2
    p1 <- exp(eta1)/(1+exp(eta1))
    p2 <- exp(eta2)/(1+exp(eta2))
    tmp <- runif(n)
    y <- (tmp < p1) + (tmp < p2)
    fit <- lrm(y~x)
    fit$stats[5]
}

out <- replicate(1000, tmpfun(100, -1/2, 1/4, 1/4))
mean( out < 0.05 )

Comments

+1, यह एक बहुत मजबूत, सार्वभौमिक दृष्टिकोण है। मैंने अक्सर इसका इस्तेमाल किया है। मैं एक अन्य विशेषता का सुझाव देना चाहता हूं: आप उन अधिकतम लिए डेटा उत्पन्न कर सकते हैं, जिन पर आप विचार करेंगे, फिर उन डेटा के अनुपात के लिए मॉडल को नियमित अंतराल पर क्रमिक रूप से फिट करके फिट करें (जैसे, n = 100 , 120, 140, 160, 180, और 200)। प्रत्येक उत्पन्न किए गए डेटासेट से पी-मान को बचाने के बजाय, आप पी-मान की एक पंक्ति को बचा सकते हैं। प्रत्येक स्तंभ पर एवरेजिंग आपको एक त्वरित और गंदे अर्थ देता है कि कैसे शक्ति w / बदल रही है , और आपको एक उचित समय पर जल्दी से हॉन करने में मदद करता है। $N$$N$$N$

— गूँज - मोनिका

@gung: आपकी टिप्पणी से समझ में आता है, क्या आप अपने कोड जोड़ने का मन करेंगे ताकि R में कम अनुभव वाले लोग भी इसका लाभ उठा सकें? धन्यवाद

मैं इसे फिर से देख रहा हूं और मेरे पास कुछ सवाल हैं: 1) 1:10 पर x वर्दी क्यों है? 2) आप इसे 1 से अधिक स्वतंत्र चर के लिए कैसे सामान्य करेंगे?

— पीटर Flom - को पुनः स्थापित मोनिका

@PeterFlom, x को कुछ होना था, इसलिए मैंने (मनमाने ढंग से) इसे 0 और 10 के बीच एक समान करने के लिए चुना, यह सामान्य, गामा, आदि भी हो सकता था। सबसे अच्छा यह होगा कि हम जो वास्तविक उम्मीद करते हैं, उसी के अनुरूप कुछ चुनें। x चर जैसा दिखने वाला। 1 से अधिक पूर्वसूचक चर का उपयोग करने के लिए, उन्हें स्वतंत्र रूप से उत्पन्न करें (या एक बहुभिन्नरूपी सामान्य, कोपूला, आदि से) तो बस उन सभी को eta1 टुकड़े में शामिल करें, जैसे eta1 <- beta0 + beta1*x1 + beta2*x2 + beta3*x3।

— ग्रेग स्नो

@ABC, नकल न करना आपको केवल एक ही निर्णय देगा, आपको यह निर्धारित करने के लिए प्रतिकृति की आवश्यकता है कि परीक्षण कितनी बार अस्वीकार करता है (शक्ति की परिभाषा)। replicateफ़ंक्शन में नहीं है और संशोधित नहीं करता है। फ़ंक्शन एक पुनरावृत्ति के लिए पी-मान (जो फिट $ आँकड़े [5] में है) लौटाता है, फ़ंक्शन को 1,000 बार चलाता है (या जो भी संख्या आप निर्दिष्ट करते हैं) और 1,000 पी-मान लौटाता है, meanफ़ंक्शन तब अनुपात का अनुपात करता है परीक्षण जो null को पर अस्वीकार कर देंगे । $\alpha=0.05$

— ग्रेग स्नो

Answer 2

मैं स्नो के जवाब में एक और बात जोड़ूंगा (और यह सिमुलेशन के माध्यम से किसी भी शक्ति विश्लेषण पर लागू होता है) - ध्यान दें कि क्या आप 1 या 2 पूंछ वाले परीक्षण की तलाश कर रहे हैं। G * जैसे लोकप्रिय प्रोग्राम 1-टेल्ड टेस्ट के लिए पावर डिफॉल्ट करते हैं, और यदि आप यह देखने की कोशिश कर रहे हैं कि क्या आपके सिमुलेशन उनसे मेल खाते हैं (हमेशा एक अच्छा विचार जब आप यह करना सीख रहे हैं), तो आप पहले चेक करना चाहेंगे।

स्नो के रन-टू-टेस्ट का परीक्षण करने के लिए, मैं फंक्शन इनपुट्स में "टेल" नामक एक पैरामीटर जोड़ूंगा, और फ़ंक्शन में कुछ इस तरह से डालूंगा:

 #two-tail test
  if (tail==2) fit$stats[5]

  #one-tail test
  if (tail==1){
    if (fit$coefficients[5]>0) {
          fit$stats[5]/2
    } else 1

1-पूंछ वाला संस्करण मूल रूप से यह देखने के लिए जांचता है कि गुणांक सकारात्मक है, और फिर आधे में पी-मूल्य में कटौती करता है।

Answer 3

स्नो के उत्कृष्ट उदाहरण के अलावा, मेरा मानना ​​है कि आप मौजूदा डेटासेट से फिर से सैंपलिंग करके एक पावर सिमुलेशन भी कर सकते हैं, जिसका प्रभाव आपके पास है। काफी बूटस्ट्रैप नहीं है, क्योंकि आप एक ही n , लेकिन एक ही विचार का नमूना-प्रतिस्थापन नहीं कर रहे हैं ।

इसलिए यहाँ एक उदाहरण है: मैंने थोड़ा आत्म-प्रयोग किया, जो एक सकारात्मक बिंदु-अनुमान में बदल गया, लेकिन क्योंकि यह बहुत कम था, क्रमिक लॉजिस्टिक प्रतिगमन में लगभग सांख्यिकीय रूप से महत्वपूर्ण नहीं था। उस बिंदु-अनुमान के साथ, मुझे कितने बड़े एन की आवश्यकता होगी? विभिन्न संभावित n के लिए , मैंने कई बार एक डेटा जनरेट किया और क्रमिक लॉजिस्टिक रिग्रेशन चलाया और देखा कि पी- पॉवेल कितना छोटा था:

library(boot)
library(rms)
npt <- read.csv("http://www.gwern.net/docs/nootropics/2013-gwern-noopept.csv")
newNoopeptPower <- function(dt, indices) {
    d <- dt[sample(nrow(dt), n, replace=TRUE), ] # new dataset, possibly larger than the original
    lmodel <- lrm(MP ~ Noopept + Magtein, data = d)
    return(anova(lmodel)[7])
}
alpha <- 0.05
for (n in seq(from = 300, to = 600, by = 30)) {
   bs <- boot(data=npt, statistic=newNoopeptPower, R=10000, parallel="multicore", ncpus=4)
   print(c(n, sum(bs$t<=alpha)/length(bs$t)))
}

आउटपुट के साथ (मेरे लिए):

[1] 300.0000   0.1823
[1] 330.0000   0.1925
[1] 360.0000   0.2083
[1] 390.0000   0.2143
[1] 420.0000   0.2318
[1] 450.0000   0.2462
[1] 480.000   0.258
[1] 510.0000   0.2825
[1] 540.0000   0.2855
[1] 570.0000   0.3184
[1] 600.0000   0.3175

इस मामले में, n = 600 पर बिजली 32% थी। बहुत उत्साहजनक नहीं।

(यदि मेरा अनुकार दृष्टिकोण गलत है, तो कृपया मुझे कोई बताएं। मैं नैदानिक ​​परीक्षणों की योजना बनाने के लिए पावर सिमुलेशन पर चर्चा करने वाले कुछ मेडिकल पेपर बंद कर रहा हूं, लेकिन मैं अपने सटीक कार्यान्वयन के बारे में निश्चित नहीं हूं।)

Answer 4

पहले सिमुलेशन का उल्लेख (हिम द्वारा सुझाया गया; /stats//a/22410/231675 ):

मुझे अभी भी यकीन नहीं है कि सिमुलेशन को अधिक (विशेष रूप से, तीन) स्वतंत्र चर के साथ कैसे दिखना चाहिए। मैं समझता हूं कि मुझे उन सभी को eta1 पीस में शामिल करना चाहिए, जैसे कि eta1 <- Beta0 + Beta1 * X1 + Beta2 * x2 + beta3 * x3 '' (जैसा कि ऊपर बताया गया है)। लेकिन मुझे नहीं पता कि फ़ंक्शन में बाकी मापदंडों को कैसे समायोजित किया जाए। किसी ने मुझे इस के साथ मदद कर सकता है?

Comments

मुझे लगता है कि यदि आप इस प्रश्न के लिंक के साथ एक नया प्रश्न पूछते तो आपको बेहतर प्रतिक्रिया मिलती।

— mdewey