मैं BUGS / JAGS / STAN के साथ एक अनुपात कैसे बना सकता हूं?

Question

मैं एक मॉडल बनाने की कोशिश कर रहा हूं, जहां प्रतिक्रिया एक अनुपात है (यह वास्तव में एक पार्टी को निर्वाचन क्षेत्रों में मिले वोटों का हिस्सा है)। इसका वितरण सामान्य नहीं है, इसलिए मैंने इसे बीटा वितरण के साथ मॉडल करने का निर्णय लिया। मेरे पास कई भविष्यवक्ता भी हैं।

हालाँकि, मुझे नहीं पता कि इसे BUGS / JAGS / STAN में कैसे लिखा जाता है (JAGS मेरी सबसे अच्छी पसंद होगी, लेकिन यह वास्तव में मायने नहीं रखता है)। मेरी समस्या यह है कि मैं भविष्यवक्ताओं द्वारा मापदंडों का योग बनाता हूं, लेकिन फिर मैं इसके साथ क्या कर सकता हूं?

कोड कुछ इस तरह होगा (JAGS सिंटैक्स में), लेकिन मुझे पता है कि पैरामीटर y_hatऔर yमापदंडों को "लिंक" कैसे किया जाता है ।

for (i in 1:n) {
 y[i] ~ dbeta(alpha, beta)

 y_hat[i] <- a + b * x[i]
}

( y_hatसिर्फ मापदंडों और भविष्यवाणियों का क्रॉस-उत्पाद है, इसलिए निर्धारक संबंध हैं। aऔर bवे गुणांक हैं जो मैं अनुमान लगाने की कोशिश करता हूं, xएक भविष्यवक्ता होने के नाते)।

आपके सुझाव के लिए धन्यवाद!

Comments

A, b, y_hat क्या हैं? आपको अपने मॉडल को स्पष्ट रूप से परिभाषित करना चाहिए। वैसे BUGS सिंटेक्स गणितीय सिंटैक्स के करीब है। इस प्रकार यदि आप अपने मॉडल को गणितीय भाषा में लिखना जानते हैं तो लगभग सभी काम हो जाते हैं।

— स्टीफन लॉरेंट

स्टीफन, धन्यवाद। मैंने a, b, y_hat को परिभाषित करने के लिए प्रश्न संपादित किया। मैं उत्तर को गणितीय रूप से नहीं जानता, अन्यथा उत्तर वास्तव में बहुत आसान होगा;;

— जोएल

मुझे संदेह है कि मैं इस तथ्य पर निर्माण कर सकता हूं कि ई (y) = अल्फा / (अल्फा + बीटा), लेकिन मैं वास्तव में यह पता नहीं लगा सकता कि वास्तव में कैसे।

— जोएल

Answer 1

बीटा प्रतिगमन दृष्टिकोण के मामले में reparameterize है और φ । जहां μ आपको भविष्यवाणी करने वाले y_hat के बराबर होगा। इस parameterization में आप होगा α = μ × φ और β = ( 1 - μ ) × φ । तब आप μ को रैखिक संयोजन के लॉग के रूप में मॉडल कर सकते हैं । $\mu$$\phi$$\mu$$\alpha=\mu\times\phi$$\beta=(1-\mu) \times \phi$$\mu$$\phi$ या तो अपना स्वयं का पूर्व हो सकता है (0 से अधिक होना चाहिए), या कोवरिएट्स पर भी मॉडलिंग की जा सकती है (इसे 0 से अधिक रखने के लिए एक लिंक फ़ंक्शन चुनें, जैसे कि घातीय)।

संभवतः कुछ इस तरह:

for(i in 1:n) {
  y[i] ~ dbeta(alpha[i], beta[i])
  alpha[i] <- mu[i] * phi
  beta[i]  <- (1-mu[i]) * phi
  logit(mu[i]) <- a + b*x[i]
}
phi ~ dgamma(.1,.1)
a ~ dnorm(0,.001)
b ~ dnorm(0,.001)

Comments

धन्यवाद, यह बहुत मददगार है! मैं आपकी सलाह से एक मॉडल फिट करने की कोशिश कर रहा हूं।

— जोएल

हालाँकि, जब मैं मॉडल चलाता हूं, तो मुझे त्रुटियां मिलती हैं जैसे: "नोड y में त्रुटि [6283] अमान्य माता-पिता मूल्य"। किसी भी विचार यहाँ क्या हो रहा है?

— जोएल

@ जोएल, y [6283] का मूल्य क्या है? क्या आपने यह सुनिश्चित कर लिया है कि अल्फाजों और बेतों के मूल्य कानूनी मूल्यों तक ही सीमित हैं? मुझे उम्मीद है कि कुछ 0 या उससे नीचे चला गया होगा और यह त्रुटि देता है।

— ग्रेग स्नो

नहीं, मैंने जाँच की कि, मेरे सभी y मान 0 से (और 1 से हीन) श्रेष्ठ हैं। हो सकता है कि मेरे पुजारी किसी समय अनुभवजन्य y मूल्यों से टकराते हों? लेकिन मुझे नहीं पता कि यह कैसे जांचना है, और मेरे पुजारी समझदार हैं - कम से कम मुझे!

— जोएल

@ कोलिन, मैं JAGS को अच्छी तरह से नहीं जानता, इसलिए बेहतर हो सकता है कि किसी मंच पर विशेष रूप से JAGS के लिए कहा जाए। या इसे एक अलग टूल में आज़माएं, मुझे लगता है कि मुझे इन दिनों स्टेन फॉर बेयस पसंद है।

— ग्रेग स्नो

Answer 2

ग्रेग स्नो ने शानदार जवाब दिया। पूर्णता के लिए, यहाँ स्टेन सिंटैक्स में समतुल्य है। हालांकि स्टेन एक बीटा वितरण है कि आप इस्तेमाल कर सकते हैं, यह बीटा घनत्व के लघुगणक खुद क्योंकि स्थिरांक बाहर काम करने के तेजी से होता है log(y)और log(1-y)शुरू (बजाय हर बार है कि एक ही बार में गणना की जा सकती y ~ beta(alpha,beta)ही कहा जाता है)। आरक्षित lp__चर को बढ़ाकर (नीचे देखें), आप अपने नमूने में टिप्पणियों पर बीटा घनत्व के लघुगणक को जोड़ सकते हैं। मैं रैखिक भविष्यवक्ता में पैरामीटर वेक्टर के लिए "गामा" लेबल का उपयोग करता हूं।

data {
  int<lower=1> N;
  int<lower=1> K;
  real<lower=0,upper=1> y[N];
  matrix[N,K] X;
}
transformed data {
  real log_y[N];
  real log_1my[N];
  for (i in 1:N) {
    log_y[i] <- log(y[i]);
    log_1my[i] <- log1m(y[i]);
  }
}
parameters {
  vector[K] gamma;
  real<lower=0> phi;
}
model {
  vector[N] Xgamma;
  real mu;
  real alpha_m1;
  real beta_m1;
  Xgamma <- X * gamma;
  for (i in 1:N) {
    mu <- inv_logit(Xgamma[i]);
    alpha_m1 <- mu * phi - 1.0;
    beta_m1 <- (1.0 - mu) * phi - 1.0;
    lp__ <- lp__ - lbeta(alpha,beta) + alpha_m1 * log_y[i] + 
                                        beta_m1 * log_1my[i];
  }
  // optional priors on gamma and phi here
}

Comments

धन्यवाद बेन! स्टेन सिंटैक्स के रूप में अच्छी तरह से करने के लिए बहुत उपयोगी है।

— 23

स्टेन वी 2 में एक "बीटा_प्रोपियन" नमूना बयान है जो मेरा मानना ​​है कि "lp__" को सीधे हेरफेर करने की आवश्यकता को मानता है

— THK