Introduction à la statistique bayésienne: MCMC avec Stan

Introduction à la statistique bayésienne: MCMC
avec Stan
Simon Barthelmé, Université de Genève
December 1, 2014
MCMC avec Stan
I Stan est un ensemble d'outils pour l'inférence bayésienne,
contenant:
I Un langage de programmation pour dénir des modèles
statistiques bayésiens
I Un échantilloneur MCMC basé sur un algorithme appellé
Monte Carlo Hamiltonien (beaucoup plus rapide que
l'échantilloneur de Gibbs implementé dans BUGS)
I Un optimiseur type Quasi-Newton (pour trouver des
estimateurs ML/MAP)
I Interfaces R, Python, Julia
Avantages de Stan
I Pas besoin d'implémenter des algorithmes MCMC vous même
I Documentation très complète
I Open source
I Communauté de développeurs et d'utilisateurs très active,
évolue rapidement
Inconvénients de Stan
I Black box (on ne sait pas forcément toujours très bien ce qui
se passe)
I Permet d'attaquer un grand nombre de problèmes, mais pas
tous
I Tous les paramètres doivent être des valeurs continues (il
existe des moyens de contourner ce problème pour les
utilisateurs
très
avancés)
I La loi a posteriori doit être continue et dérivable
I On aura potentiellement des soucis avec les lois multimodales
(mais il n'y a pas de solutions simples à ce problème)
Comment ça marche: l'échantilloneur
I L'échantilloneur est un black box à qui on donne en entrée une
∂
fonction L (θ) et sa dérivée
∂θ L, et qui génère
(asymptotiquement) des échantillons de la loi
π (θ) = exp (L (θ))
I L'algorithme utilise les infos du gradient pour accélerer
l'échantillonage
I Monte Carlo Hamiltonien avec ajustement automatique
(NUTS, No U-Turn Sampler)
I un peu complexe, je ne vais pas l'expliquer, lisez le manuel si
ça vous intéresse
Comment ça marche: la dénition du modèle
I Vous écrivez un programme qui décrit le modèle statistique
I Quelles sont les données?
I Quels sont les paramètres?
I Quelles sont les priors sur les paramètres? (i.e.,
p (y|θ))
I Quelle est la vraisemblance? (
p (θ))
Comment ça marche: interprétation, compilation
I Interprétation: stan lit le modèle, le transforme en fonctions
C++ qui calculent:
L (θ) = log p (y|θ) + log p (θ)
∂
L
, sa dérivée (par diérentiation automatique)
∂θ
I Le log de la loi a posteriori
I
I Stan compile les fonctions C++ (cette étape prend du temps)
I On peut maintenant utiliser l'échantilloneur
Un premier exemple: loi a priori seulement
parameters {
real beta; //Coefficient
}
model {
beta ~ normal(0,1); //Gaussian prior for beta
}
Rajouter une option
data {
real<lower=0> sd_prior; //beta has prior N(0,sd_prior)
}
parameters {
real beta; //Coefficient
}
model {
beta ~ normal(0,sd_prior); //Gaussian prior for beta
}
A noter
I La structure en blocks: data { },parameters { },model { }
I La syntaxe est un mélange entre C et R
I La notation ~ pour est distribué selon
I Important: toujours déclarer les contraintes sur les variables,
ex. real<lower=0> sd_prior; real<lower=0,upper=1> proba;
Rajouter une observation
data {
real<lower=0> sd_prior; //beta has prior N(0,sd_prior)
real y;
}
parameters {
real beta; //Coefficient
}
model {
beta ~ normal(0,sd_prior); //Gaussian prior for beta
y ~ normal(beta,1); //Gaussian likelihood for y|beta
}
Rajouter *des* observations
data {
real<lower=0> sd_prior; //beta has prior N(0,sd_prior)
int<lower=1> n; //Number of observations
vector[n] y; //Observations
}
parameters {
real beta; //Coefficient
}
model {
beta ~ normal(0,sd_prior); //Gaussian prior for beta
y ~ normal(beta,1); //Gaussian likelihood for y|beta (vectorised!!!
}
Régression bayésienne
I On reprend et on étend le scénario d'hier:
I Modèle:
y
=
β+
X
∼ N
0, σ
∼ N
0, τ
β
i
σ ∼
2
2
Half-Cauchy(0, 1)
I La matrice Xn×m contient les covariés (design matrix).
I On a
m
coecients et
n
observations y
Régression bayésienne (programme Stan)
data {
int<lower=1> n; //Number of observations
int<lower=1> m; //Number of covariates matrix[n,m]
matrix[n,m] X; //Design matrix real<lower=0>
real<lower=0> sd_prior; //Coefficients have prior N(0,sd_prior)
vector[n] y; //Outcomes
}
parameters {
vector[m] beta; //Regression coefficients
real<lower=0> sd_noise; //Std. dev of measurement noise
}
model {
sd_noise ~ cauchy(0,1); //Half-cauchy prior on sd_noise
beta ~ normal(0,sd_prior); //Gaussian prior for coefficients
y ~ normal(X*beta,sd_noise);
}
Qu'est-ce qui sort de Stan?
I Par défaut, Stan lance quatre chaînes MCMC initialisées à des
endroits diérents, avec 1000 itérations burn-in et 1000
itérations conservées
I Si les chaînes se comportent bien, les résultats devraient de
toutes les chaînes devraient être semblables
I Toujours vérier que les chaînes ne sont pas trop autocorrélées!
Comment travailler avec Stan?
I Toujours commencer par le modèle le plus simple possible, en
faisant des tests avec des données synthétiques
I Vérier sur des données synthétiques que la loi a posteriori se
concentre sur les bonnes valeurs (quand la quantité de données
est élevée).
I Sur les vraies données, plutôt commencer par quelque chose de
simple, en introduisant de la complexité si elle est nécessaire
I Vérier que le posterior predictive est relativement sensé
I Si problème: la documentation est très riche et la
communauté d'utilisateurs est active