Come posso modellare una proporzione con BUGS / JAGS / STAN?


10

Sto cercando di costruire un modello in cui la risposta è proporzionale (in realtà è la percentuale di voti che un partito ottiene nei collegi elettorali). La sua distribuzione non è normale, quindi ho deciso di modellarlo con una distribuzione beta. Ho anche diversi predittori.

Tuttavia, non so come scriverlo in BUGS / JAGS / STAN (JAGS sarebbe la mia scelta migliore, ma non importa davvero). Il mio problema è che faccio una somma di parametri dai predittori, ma poi cosa posso farci?

Il codice sarebbe qualcosa del genere (nella sintassi JAGS), ma non so come "collegare" i parametri y_hate y.

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

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

( y_hatè solo il prodotto incrociato di parametri e predittori, quindi la relazione deterministica. aE bsono i coefficienti che cerco di stimare, xessendo un predittore).

Grazie per i vostri suggerimenti!


Cosa sono a, b, y_hat? Dovresti definire chiaramente il tuo modello. A proposito, la sintassi di BUGS è vicina alla sintassi matematica. Quindi, se sai come scrivere il tuo modello in linguaggio matematico, quasi tutto il lavoro è fatto.
Stéphane Laurent,

Stéphane, grazie. Ho modificato la domanda per definire a, b, y_hat. Neanche io conosco matematicamente la risposta, altrimenti la risposta sarebbe davvero molto più semplice ;-)
Joël

Ho il sospetto che potrei basarmi sul fatto che E (y) = alpha / (alpha + beta), ma non riesco davvero a capire come esattamente.
Joël,

Risposte:


19

L'approccio di regressione beta è di ri-parametrizzare in termini di e . Dove sarà l'equivalente di y_hat che prevedi. In questa parametrizzazione avrai e . Quindi puoi modellare come logit della combinazione lineare. può avere il suo precedente (deve essere maggiore di 0), oppure può essere modellato anche su covariate (scegliere una funzione di collegamento per mantenerlo maggiore di 0, come esponenziale).ϕ μ α = μ × ϕ β = ( 1 - μ ) × ϕ μ ϕμϕμα=μ×ϕβ=(1μ)×ϕμϕ

Forse qualcosa come:

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)

Grazie, è molto utile! Sto cercando di adattare un modello al tuo consiglio.
Joël,

Tuttavia, quando eseguo il modello, ottengo errori come: "Errore nel nodo y [6283] Valori padre non validi". Qualche idea di cosa sta succedendo qui?
Joël,

@ Joël, qual è il valore di y [6283]? ti sei assicurato che i valori di alfa e beta siano limitati ai valori legali? Mi aspetto che qualcosa sia andato a 0 o meno e che dia l'errore.
Greg Snow,

No, l'ho verificato, tutti i miei valori y sono rigorosamente superiori a 0 (e inferiori a 1). Forse i miei priori si scontrano con i valori empirici y ad un certo punto? Ma non so come controllarlo, e i miei priori sembrano sensati, almeno per me!
Joël,

1
@colin, non conosco bene JAGS, quindi potrebbe essere meglio chiederlo su un forum appositamente per JAGS. O provalo con uno strumento diverso, trovo che mi piaccia Stan per Bayes in questi giorni.
Greg Snow,

18

Greg Snow ha dato un'ottima risposta. Per completezza, ecco l'equivalente nella sintassi di Stan. Sebbene Stan abbia una distribuzione beta che potresti usare, è più veloce elaborare tu stesso il logaritmo della densità beta perché le costanti log(y)e log(1-y)possono essere calcolate una volta all'inizio (piuttosto che ogni volta che y ~ beta(alpha,beta)verrebbero chiamate). Aumentando la lp__variabile riservata (vedi sotto), puoi sommare il logaritmo della densità beta sulle osservazioni nel tuo campione. Uso l'etichetta "gamma" per il vettore dei parametri nel predittore lineare.

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
}

Grazie Ben! Molto utile avere anche la sintassi di Stan.
Joël,

Stan v2 ha una dichiarazione di campionamento "beta_proportion" che credo ovvia alla necessità di manipolare direttamente "lp__"
THK,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.