Algorithmes de Métropolis-Hasting et recuit simulé

1
Université de Bordeaux
Master 2 MIMSE - UE : Outils de simulations 2
Année 2015-2016
Examen - 1ère Session - Durée 2h00
Les documents (notes de cours, polycopiés) ne sont pas autorisés.
L’examen consiste à rédiger un programme en Scilab que vous devez envoyer à l’adresse
[email protected] sous la forme d’un e-mail avec comme sujet “Examen
Outils de Simulations 2 - Nom Prénom” et dont le contenu est un code Scilab commenté.
Algorithmes de Métropolis-Hasting et recuit simulé
Dans cet exercice, on se propose d’utiliser deux approches algorithmiques pour déterminer
la médiane d’une mesure de probabilité discrète.
1.1
Rappels sur l’algorithme de Métropolis-Hasting
On dispose des éléments suivants :
- soit E un espace d’états finis, et π une loi de probabilité sur E telle que π(x) > 0
pour tout x ∈ E,
- soit Q un noyau de Markov irréductible tel que si Q(x, y) > 0 alors Q(y, x) > 0
pour tout (x, y) ∈ E × E.
Pour simuler une chaı̂ne de Markov (Xn )n≥0 qui admet π comme loi stationnaire, on
considère l’algorithme suivant :
1. Initialisation n = 0 : choisir X0 ∈ E.
2. Simuler Y ∈ E selon la loi Q(Xn , ·) i.e. P(Y = y) = Q(Xn , y) pour tout y ∈ E.
3. Simuler U selon
la loi uniforme
sur [0, 1].
π(Y )Q(Y,Xn )
Si U < min 1, π(Xn )Q(Xn ,Y ) alors Xn+1 = Y , et sinon Xn+1 = Xn .
4. Incrémenter n de 1 i.e. n 7→ n + 1 et reprendre l’algorithme à l’étape 2.
3k Dans la suite, on considère l’espace d’états E = M
avec M = 50 où k est
−M ≤k≤M
un entier relatif variant entre −M et M , et on souhaite étudier la mesure π sur E définie
par
1
2
π(x) =
f (x), avec f (x) = e−x (2 + sin(5x) + sin(2x)),
(1)
Zπ
pour tout x ∈ E, où Zπ est une constante de normalisation. Dans la suite, vous pourrez utiliser le code Scilab ci-dessous qui permet de définir l’espace E, et de représenter
graphiquement la fonction f : E → R.
2
clf();
// Mesure non-normalisee à simuler
function p=f(x)
p=exp(-x.^2) .* (2 + sin(x*5) + sin(x*2));
endfunction
M = 50;
E = 3*(-M:M)/M;
p=[];
for j = 1:length(E)
p=[p f(E(j))];
end
plot2d(E,p);
xtitle(’Mesure cible - Non-normalisee’);
On considère également le choix suivant pour le noyau de proposition Q :

0
si |x − y| > ∆ ou x = y




si x > −3 et y = x − ∆
 α
1 − α si x < +3 et y = x + ∆
Q(x, y) =


1
si x = −3 et y = x + ∆



1
si x = +3 et y = x − ∆
pour tout (x, y) E × E, où ∆ =
3
M
et α est un paramètre entre 0 et 1.
Questions à rendre par e-mail (code Scilab)
Q. 1 Compléter le code Scilab ci-dessous pour la construction de la matrice Q.
// Question 1
// Construction de la matrice Q
alpha = 0.001;
Q = zeros(length(E),length(E));
Q(1,2) = // ? //;
Q(2*M+1,2*M) = // ? //;
for (k =2:(2*M))
// ? // = alpha ;
// ? // = // ? //;
end
Q. 2 Compléter le code Scilab ci-dessous afin de construire une fonction proposition,
qui sachant Xn (variable d’entrée x), génère une variable aléatoire Y (variable de sortie
xp) selon la loi Q(Xn , ·) :
// Question 2
// Proposition
function xp = proposition(x,alpha)
3
if (x == E(1)) then
xp = // ? //;
elseif (x == // ? //) then
xp = E(2*M);
else
u = // ? //;
j = find(E==x);
if (u < // ? //) then
xp = // ? //;
else
xp = // ? //;
end
end
endfunction
Q. 3 Compléter le code Scilab ci-dessous, afin d’implémenter l’algorithme de MétropolisHasting qui permet de simuler N = 105 réalisations d’une variable aléatoire de loi π
donnée par (1).
// Question 3
// Initilisation de l’algorithme
k = 10000; // Periode chauffe
N = 50000; // Longueur finale de la chaine
n = k+N;
X = zeros(n,1); // Vecteur contenant les realisations de la chaine de Markov
x = 0; // Position initiale de la chaine
function y=h(u)
y=min(1,u);
endfunction
for i = 1:n
// Proposition
// ? //
// Acceptation / Rejet
j = find(E==x);
jp = find(E==xp);
// ? //
end
// Suppression des k premieres valeurs
Xfinal = X(k:n);
Utiliser le code Scilab ci-dessous pour montrer, à l’aide d’un histogramme, l’adéquation
du résultat des simulations avec le graphe de la loi π afin de vérifier que vous avez bien
4
simulé des réalisations d’une variable aléatoire suivant cette loi.
// Question 4
scf();
histplot(E,Xfinal,2);
xtitle(’Simulation par algorithme de Metropolis-Hasting’ );
Q. 4 Quelle(s) valeur(s) de α vous semble donner de bons résultats (donner votre réponse
sous forme de commentaires) ?
Q. 5 Utiliser les simulations obtenus par l’algorithme de Metropolis-Hasting pour déterminer
plusieurs estimateur de la médiane de la loi π donnée par (1) pour α = 10−3 , α = 0.1,
et α = 0.5. Noter vos résultats sous la forme de commentaires dans votre fichier Scilab à
l’aide du code ci-dessous
//
//
//
//
Question 5
alpha = 0.001 - mediane = // ? //
alpha = 0.1 - mediane = // ? //
alpha = 0.5 - mediane = // ? //
Dans la suite de l’exercice, on propose d’utiliser l’algorithme du recuit simulé pour
approcher numériquement la médiane de la loi π. Pour cela, on propose de déterminer un
point y ∗ ∈ E qui minimise la fonction y 7→ V (y) sur l’ensemble E où
X
V (y) =
π(x)|y − x|,
x∈E
pour tout y ∈ E. On rappelle que la mesure de Gibbs πT associée au potentiel V et à la
température T > 0 est définie par
1
1
πT (y) =
exp − V (y) ,
ZT
T
pour tout y ∈ E, où ZT est une constante de normalisation.
Q. 6 Compléter le code Scilab ci-dessous pour implémenter un algorithme de recuit simulé
pour déterminer un minimum de la fonction V avec le choix de décroissance logarithmique
Ti = 1/log(i + 1) pour le paramètre de température où i est l’itération courante de l’algorithme. Vous êtes libre du choix de noyau de proposition Q, et vous prendrez y = 0 comme
paramètre d’initialisation.
// Question 6
// Potentiel V
w=[];
for j = 1:length(E)
w=[w f(E(j))];
end
function res=V(y)
5
res = sum(w.*abs(y-E));
endfunction
// Initilisation de l’algorithme
n = 5000;
Y = zeros(n,1); // Vecteur contenant les réalisations de la chaine de Markov
y = 0;
C = 1;
for i = 1:n
// ? //
// Choix de la température
temp = C/log(i+1);
// ? //
end
plot(Y)
Y(n)
Q. 7 Donner un code Scilab pour déterminer la valeur y ∗ ∈ E où la fonction V atteint
son minimum (sur E). La valeur Y(n) obtenue par recuit simulé converge-t-elle vers y ∗ ?
Q. 8 La valeur Y(n) obtenue par recuit simulé pour la minimisation de V converge-telle vers la valeur de la médiane calculée précédemment à partir de simulations d’une
chaine de Markov de loi stationnaire π ? S’il existe une différence, comment pouvez-vous
l’expliquer ? Noter vos résultats sous la forme de commentaires dans votre fichier Scilab.