Petits exposés variés Xavier Dupré http ://www.xavierdupre.fr/

Petits exposés variés
Xavier Dupré
http ://www.xavierdupre.fr/
Table des matières
0.0.1
0.0.2
0.0.3
0.0.4
0.0.5
0.0.6
0.0.7
0.0.8
0.0.9
0.0.10
0.0.11
0.0.12
0.0.13
Enoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme et convergence . . . . . . . . . . . . . . . . . . . . . . . .
Méthode du second ordre . . . . . . . . . . . . . . . . . . . . . . . .
Minimisation avec gradient stochastique . . . . . . . . . . . . . . . .
Premier exemple : optimisation d’une fonction quadratique . . . . .
Court rappel sur l’estimateur du maximum de vraisemblance . . . .
Second exemple : proportion de mâles chez les poissons . . . . . . . .
Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Premier exemple, fonction quadratique . . . . . . . . . . . . . . . . .
Second exemple, proportion de mâles et de femelles chez les poissons
Simulation d’une série (Xi )i . . . . . . . . . . . . . . . . . . . . . . .
Estimation des paramètres avec une méthode du premier degré . . .
Estimation des paramètres avec une méthode du second degré . . . .
Index
0.0.1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
5
7
9
9
13
14
14
17
17
18
22
25
Enoncé
Lorsqu’on doit trouver le minimum d’une fonction définie sur un espace vectoriel, le premier réflexe consiste
à dériver la fonction puis à l’annuler de manière à obtenir un système d’équation. Il reste ensuite à
déterminer si les zéros de la dérivée correspondent à un minimum ou à un maximum. Cependant, il n’est
pas toujours possible de résoudre le système d’équation obtenu. Par exemple, la fonction f (x) = cos(x)+ex
a pour dérivée f 0 (x) = − sin(x) = ex . Résoudre l’équation f 0 (x) = 0 est impossible.
C’est pourquoi il existe des méthodes de résolution approchées qui déterminent numériquement le minimum
de la fonction. Il existe des algorithmes permettant de trouver une solution approchée à condition toutefois
que la fonction à maximiser ou minimiser soit dérivable. Plusieurs variantes sont proposées regroupées
sous le terme de descente de gradient ou méthode de Newton. Par la suite, on cherchera à minimiser une
fonction g. Maximiser cette même fonction revient à minimiser la fonction −g.
0.0.2
Algorithme et convergence
∗
Soit g : ℝd −→ ℝ une fonction dérivable dont il faut trouver x = arg min g (x). L’algorithme suivant
x∈ℝ
propose une méthode permettant à partir d’un x0 ∈ ℝd quelconque de se rapprocher petit à petit du
TABLE DES MATIÈRES
3
minimum x∗ comme le montre le schéma 0.1 dans le cas où g (x) = x2 .
Algorithme 0.1 : descente de gradient de Newton
Soit g : ℝd −→ ℝ une fonction dérivable et minorée. On cherche à déterminer le minimum de la
fonction g. Soit x0 ∈ ℝd . Soit (t )t⩾0 une suite réelle positive vérifiant :
∞
∞
X
X
t = ∞ et
2t < ∞
t=0
t=0
Etape A : initialisation
t ←− 0
Etape B : mise à jour
t ←− t + 1
∂g
(xt )
xt ←− xt−1 − t ∂x
Etape C : condition d’arrêt
Si f (xt ) ≈ f (xt−1 ), l’algorithme s’arrête, sinon on retourne à l’étape B.
On note xt l’abscisse à l’itération t.
∂g (xt )
On note
le gradient de g (x) = x2 .
∂x
L’abscisse à l’itération
t + 1 sera :
∂g (xt )
xt+1 = xt − εt
∂x
εt est le pas de gradient à l’itération t.
Figure 0.1 : Minimisation par descente de gradient. A chaque itération, on se déplace dans le sens opposé à celui
du gradient, direction le minimum est susceptible de se trouver.
L’étape C détermine si l’algorithme doit continuer à chercher le minimum de la fonction g ou si la valeur
approchée est satisfaisante puisque, aux alentours de ce minimum, le gradient est presque nul et la suite (xt )
presque constante. La condition f (xt ) ≈ f (xt−1 ) peut
par exemple être interprétée comme une différence
f (xt )−f (xt−1 ) relative d’une itération à la suivante : f (xt−1 ) < A où A est une constante positive petite. Plus elle
est petite, plus la précision sera grande. Il est aussi possible d’arrêter l’algorithme dès que f (xt ) > f (xt−1 )
mais la suite (f (xt ))t n’est pas toujours décroissante, c’est pourquoi la condition d’arrêt précédente est
préférable.
0
La suite (t )t doit vérifier quelques contraintes comme la suite t = 1+t
. Ces contraintes assurent la
TABLE DES MATIÈRES
4
convergence de l’algorithme vers un minimum de la fonction comme le montre le théorème suivant.
Théorème 0.2 : convergence de la méthode de Newton (Bottou1991)
Soit une fonction continue g : W ∈ ℝM −→ ℝ, de classe C 1 . On suppose les hypothèses suivantes
vérifiées :
H1 arg min g (W ) = {W ∗ } est un singleton
W ∈ℝq
H2 ∀ε > 0,
inf
|W −W ∗ |>ε
(W − W ∗ )0 .∇g (W ) > 0
H3 ∃ (A, B) ∈ ℝ2 tels que ∀W ∈ ℝp , k∇g (W )k2 ⩽ A2 + B 2 kW − W ∗ k2
P
P 2
H4 la suite (εt )t⩾0 vérifie, ∀t > 0, εt ∈ ℝ∗+ et
εt = +∞,
εt < +∞
t⩾0
t⩾0
Alors la suite (Wt )t⩾0 construite de la manière suivante :
W0 ∈ ℝM et ∀t ⩾ 0, Wt+1 = Wt − εt ∇g (Wt )
vérifie
lim Wt = W ∗
t−→+∞
L’hypothèse H1 implique que le minimum de la fonction g est unique et l’hypothèse H2 implique que le
demi-espace défini par l’opposé du gradient contienne toujours le minimum de la fonction g.
Démonstration (théorème 0.2) :
Partie A (démonstration de 0.2)
P
P 2
ut < +∞
εt < +∞, ut ∼ ε2t x2 , on a
Soit la suite ut = ln 1 + ε2t x2 avec x ∈ ℝ, comme
t⩾0
Par conséquent, si vt = eut alors
T
Q
t⩾0
T →∞
vt −→ D ∈ ℝ
t=1
Partie B (démonstration de 0.2)
On pose ht = kWt − W ∗ k2
Donc :
ht+1 − ht = kWt − εt ∇g (Wt ) − W ∗ k2 − kWt − W ∗ k2
(0.1)
Par conséquent :
ht+1 − ht = −2εt (Wt − W ∗ )0 ∇g (Wt ) + ε2t k ∇C (Wt )k2 ⩽ ε2t k ∇g (Wt )k2 ⩽ ε2t A2 + B 2 ht
{z
}
|
>0
D’où :
ht+1 − ht 1 + ε2t B 2 ⩽ ε2t A2
On pose πt =
t
Y
k=1
1 + ε2k B 2
−1
alors, en multipliant des deux côtés par πt+1 , on obtient :
TABLE DES MATIÈRES
5
πt+1 ht+1 − πt ht ⩽ ε2t A2 πt+1
q
q
q
X
X
X
ε2t A2 Π −→ 0
ε2t A2 Π ⩽
ε2t A2 πt+1 ⩽
d’où πq+1 hq+1 − πp hp ⩽
t=p
t=p
Comme la série
P
t=p
t−→∞
(πt+1 ht+1 − πt ht ) vérifie le critère de Cauchy, elle est convergente. Par conséquent :
t
lim πq+1 hq+1 = 0 = lim Πhq+1
q→∞
q→∞
D’où :
lim hq = 0
q→∞
(0.2)
Partie C (démonstration de 0.2)
P
La série
(ht+1 − ht ) est convergente car Πht ∼ πt ht .
t
ε2t
t⩾0
P
k ∇g (Wt )k2 l’est aussi (d’après H3).
D’après (0.1), la série
P
εt (Wt − W ∗ )0 ∇g (Wt ) est donc convergente. Or d’après les hypothèses (H2, H4),
t⩾0
elle ne peut l’être que si :
lim Wt = W ∗
t→∞
(0.3)
(0.2) u
t
Ce théorème peut être étendu dans le cas où la fonction g n’a plus un seul minimum global mais plusieurs
minima locaux (voir [?]), dans ce cas, la suite (Wt ) converge vers un mimimum local. Une généralisation
de ce théorème est présentée dans [?].
Si ce théorème prouve la convergence de la méthode de Newton, il ne précise pas à quelle vitesse cette
convergence s’effectue et celle-ci peut parfois être très lente. Plusieurs variantes ont été développées regroupées sous le terme de méthodes de quasi-Newton, ou méthodes du second ordre, dans le but d’améliorer
la vitesse de convergence.
0.0.3
Méthode du second ordre
L’algorithme 0.1 fournit le canevas des méthodes d’optimisation du second ordre. Seule la mise à jour des
coefficients (étape B) est différente : elle prend en compte les dernières valeurs des coefficients ainsi que
les derniers gradients calculés. Ce passé va être utilisé pour estimer une direction de recherche pour le
minimum différente de celle du gradient, cette direction est appelée gradient conjugué (voir [?]).
La figure 0.2 est couramment employée pour illustrer l’intérêt des méthodes d’optimisation du second ordre
ou méthode de gradient conjugué. Le problème consiste à trouver le minimum d’une fonction quadratique,
par exemple, G (x, y) = 3x2 +y 2 . Tandis que le gradient est orthogonal aux lignes de niveaux de la fonction
G, le gradient conjugué se dirige plus sûrement vers le minimum global.
Ces techniques sont basées sur une approximation du second degré de la fonction à minimiser. On note
toujours g : ℝd −→ ℝ la fonction à minimiser. Au voisinage de x0 , un développement limité donne :
g (x) = g (x0 ) +
∂g (x0 )
∂ 2 g (x0 )
(x − x0 ) + (x − x0 )0
(x − x0 ) + o kx − x0 k2
∂x
∂x2
TABLE DES MATIÈRES
6
.
.
gradient
gradient conjugué .
Figure 0.2 : Gradient et gradient conjugué sur une ligne de niveau de la fonction G (x, y) = 3x2 + y 2 , le gradient
est orthogonal aux lignes de niveaux de la fonction G, mais cette direction est rarement orientée vers le minimum à
moins que le point (x, y) se situe sur un des axes des ellipses, le gradient conjugué agrège les derniers déplacements
et propose une direction de recherche plus plausible pour le minimum de la fonction.
2
g(x0 )
Par conséquent, sur un voisinage de x0 , la fonction g (x) admet un minimum local si ∂ ∂x
est définie
2
1
positive strictement . Une matrice symétrique définie strictement positive est inversible, et le minimum
est atteint pour la valeur :
xmin
−1 1 ∂ 2 g (x0 )
∂g (x0 )
= x0 +
2
∂x2
∂x
(0.4)
Néanmoins, pour un réseau de neurones, le calcul de la dérivée seconde est coûteux, son inversion également.
C’est pourquoi les dernières valeurs des coefficients et du gradient sont utilisées afin d’approcher cette
dérivée seconde ou directement son inverse. Une méthode couramment employée est l’algorithme BFGS
(Broyden-Fletcher-Goldfarb-Shano, voir [?], [?]).
Ces méthodes proposent une estimation de la dérivée seconde (ou de son inverse) utilisée en (0.4). Dans
les méthodes du premier ordre, une itération permet de calculer les poids xt+1 à partir des poids xt et du
gradient gt . Si ce gradient est petit, on peut supposer que gt+1 est presque égal au produit de la dérivée
seconde par gt . Cette relation est mise à profit pour construire une estimation de la dérivée seconde. Cette
matrice notée Bt dans l’algorithme 0.3 est d’abord supposée égale à l’identité puis actualisée à chaque
itération en tenant de l’information apportée par chaque déplacement.
Algorithme 0.3 : algorithme BFGS
Soit g : ℝd −→ ℝ une fonction dérivable et minorée. On cherche à déterminer le minimum de la
fonction g. Soit x0 ∈ ℝd . Le nombre de paramètres de la fonction f est d. n est un entier strictement
positif.
Etape A : initialisation
Le premier jeu de coefficients x0 du réseau de neurones est choisi aléatoirement.
t
←− 0
E0 ←− f (x0 )
B0 ←− Id
i
←− 0
Etape B : calcul du gradient
gt ←− ∂f
∂x (xt )
ct ←− Bt gt
1. Rappel :
∂ 2 g (x0 )
∂ 2 g (x0 )
est définie positive strictement ⇐⇒ ∀Z ∈ ℝN , Z 6= 0 =⇒ Z 0
Z>0
2
∂x
∂x2
TABLE DES MATIÈRES
7
Etape C : recherche de ∗
∗ ←− 0
faire
∗
∗
←− 2
xt+1 ←− xt − ∗ ct
tant que (fxt+1 ⩾ Et et ∗ 0)
si ∗ ≈ 0 et Bt 6= Id alors
Bt ←− Id
i
←− t
retour à l’étape B.
fin si
Etape D : mise à jour des coefficients
xt+1 ←− xt − ∗ ct
Et+1 ←− f (xt+1 )
t
←− t + 1
Etape E : mise à jour de la matrice Bt
0 B
0
si t − i ⩾ nd ou gt−1
t−1 gt−1 ⩽ 0 ou gt−1 Bt−1 (gt − gt−1 ) ⩽ 0 alors
Bt ←− Id
i
←− t
sinon
st ←− xt − xt−1
dt ←− gt − gt−1
d0t Bt−1 dt st s0t
st d0t Bt−1 + Bt−1 dt s0t
−
Bt ←− Bt−1 + 1 +
d0t st
s0t dt
d0t st
fin si
Etape F : terminaison
t
≈ 1 alors l’apprentissage a convergé sinon retour à l’étape B.
si EEt−1
Lorsque la matrice Bt est égale à l’identité (Id ), le gradient conjugué est égal au gradient. Au fur et à mesure
des itérations, cette matrice toujours symétrique évolue en améliorant la convergence de l’optimisation.
Néanmoins, la matrice Bt doit être "nettoyée" (égale à l’identité) fréquemment afin d’éviter qu’elle n’agrège
un passé trop lointain. Elle est aussi nettoyée lorsque le gradient conjugué semble trop s’éloigner du
véritable gradient et devient plus proche d’une direction perpendiculaire.
L’algorithme DFP (Davidon-Fletcher-Powell, voir [?], [?]) est aussi un algorithme de gradient conjugué qui
propose une approximation différente de l’inverse de la dérivée seconde. Pour appliquer cette méthode, il
suffit de remplacer la mise à jour de la matrice Bt dans l’étape E de l’algorithme 0.3 par la suivante :
Bt ←− Bt−1 +
0.0.4
dt d0t Bt−1 st s0t Bt−1
−
d0t st
s0t Bt−1 st
(0.5)
Minimisation avec gradient stochastique
La méthode du gradient stochastique s’applique lorsque la fonction à minimiser est une somme de fonctions
dérivables et minorées.
g(x) =
N
X
ei (x)
i=1
(0.6)
TABLE DES MATIÈRES
8
Compte tenu des courbes d’erreurs très "accidentées" (figure 0.3) dessinées par ces fonctions, il existe une
multitude de minima locaux. De ce fait, l’apprentissage global converge rarement vers le minimum global
de la fonction d’erreur lorsqu’on applique les algorithmes basés sur le gradient global. L’optimisation avec
gradient stochastique est une solution permettant de mieux explorer ces courbes d’erreurs.
De plus, les méthodes de gradient conjugué nécessite le stockage d’une matrice trop grande parfois pour
des fonctions ayant quelques milliers de paramètres (g : ℝ1000 −→ ℝ). C’est pourquoi l’apprentissage avec
gradient stochastique est souvent préféré à des méthodes du second ordre trop coûteuses en calcul et en
espace mémoire. En contrepartie, la convergence est plus lente. La démonstration de cette convergence
nécessite l’utilisation de quasi-martingales et est une convergence presque sûre (voir [?]).
Figure 0.3 : Exemple de minima locaux.
Algorithme 0.4 : optimisation stochastique
N
P
Soit g =
ei (x), ∀i, ei : ℝd −→ ℝ une fonction dérivable et minorée. On cherche à déterminer le
i=1
minimum de la fonction g. Soit x0 ∈ ℝd . Soit (t )t⩾0 une suite réelle positive vérifiant :
∞
∞
X
X
t = ∞ et
2t < ∞
t=0
t=0
Etape A : initialisation
t
←− 0
N
P
E0 ←−
ei (x0 )
i=1
Etape B : récurrence
xt,0 ←− W0
pour t0 = 0 à N − 1 faire
i
←− nombrealéatoire dans {1, . . . , N }
i
0
g
←− ∂e
∂x xt,t
xt,t0 +1 ←− xt,t0 − t g
fin pour
Et+1
←− xt,N
N
P
←−
ei (xt+1 )
t
←− t + 1
xt+1
i=1
Etape C : terminaison
t
si EEt−1
≈ 1 alors l’apprentissage a convergé sinon retour à l’étape B.
En pratique, il est utile de converser le meilleur jeu de coefficients : x∗ = arg min Eu car la suite (Eu )u⩾0
u⩾0
n’est pas une suite constamment décroissante.
TABLE DES MATIÈRES
0.0.5
9
Premier exemple : optimisation d’une fonction quadratique
La figure 0.2 illustre un exemple pour lequel l’utilisation d’un algorithme d’optimisation du second degré
est pertinente et pour le vérifier concrètement, on choisit la fonction suivante :
f (x, y) = x4 + x3 +
y2 + y
100
(0.7)
Le miminum est atteint pour (x, y) = − 34 , − 12 . Toutefois, du fait du coefficient très faible devant les
termes en y 2 et y, l’utilisation d’un algorithme de descente de gradient du premier ordre doit converger très
lentement contrairement à une méthode du second ordre, ce que le programme décrit au paragraphe 0.0.9
montrera numériquement.
0.0.6
Court rappel sur l’estimateur du maximum de vraisemblance
La méthode de l’estimateur du maximum de vraisemblance est une méthode permettant d’estimer les
paramètres d’une densité. Par exemple, on mesure les tailles d’une trentaine de personnes pour obtenir un
échantillon (X1 , . . . , Xn ). On calcule pour cet échantillon l’espérance (ou la moyenne) et l’écart-type :
v
u n
n
X
p
u1X
1
µ = 𝔼 (X) =
Xi et σ = 𝕍 (X) = t
(Xi − 𝔼 (X))2
n
n
i=1
(0.8)
i=1
Ces valeurs apparaissent souvent en statistiques, elles proviennent d’une hypothèse faite sur la loi que
suivent les variables de l’échantillon (X1 , . . . , Xn ) : une loi normale de moyenne µ et d’écart-type σ. On
suppose alors que toutes les variables Xi sont indépendantes et suivent la même loi normale de moyenne
µ et d’écart-type σ pour l’instant inconnus. Cela signifie aussi que la densité de la variable Xi a pour
expression :
(x − µ)2
1
√
exp −
f (x) =
2σ 2
2πσ
!
(0.9)
Cette expression permet par exemple de calculer la probabilité d’un événement comme le fait que les tailles
des n personnes soient inférieures à 1,80 mètres et supérieures à 1,60 mètres. Notons A cet événement.
ℙ (A) = ℙ (1, 6 ⩽ X1 ⩽ 1, 8 et ... et 1, 6 ⩽ Xn ⩽ 1, 8)
(0.10)
Etant donné que les variables de l’échantillon sont toutes indépendantes. Il est possible d’écrire que :
ℙ (A) = ℙ (1, 6 ⩽ X1 ⩽ 1, 8) × ... × ℙ (1, 6 ⩽ Xn ⩽ 1, 8) =
n
Y
ℙ (1, 6 ⩽ Xi ⩽ 1, 8)
(0.11)
i=1
On utilise maintenant le fait que Xi a pour densité f :
n Z
Y
"Z
n
Y
! #
(x − µ)2
1
√
exp −
dx
ℙ (A) =
f (x)dx =
2σ 2
2πσ
1,6
1,6
i=1
i=1
!
!
Z 1,8 Z 1,8
1
(x1 − µ)2
1
(xn − µ)2
√
=
...
exp −
... √
exp −
dx1 ...dxn
2σ 2
2σ 2
2πσ
2πσ
1,6
1,6
1,8
1,8
(0.12)
(0.13)
TABLE DES MATIÈRES
10
Cette dernière écriture fait référence à la densité d’un vecteur de variables aléatoires et indépendantes
2
1
comme par exemple le vecteur (X1 , . . . , Xn ). Puisque la densité d’une variable Xi est f (x) = √2πσ
exp − (x−µ)
,
2σ 2
la densité de l’échantillon (X1 , . . . , Xn ) est :
n
Y
f (x1 , ..., xn ) =
f (xi )
(0.14)
i=1
=
1
√
2πσ
n Y
n
i=1
(xn − µ)2
exp −
2σ 2
!
(0.15)
On utilise pour cela le fait que la densité d’un ensemble de variables indépendantes est le produit des
densités. En fait, cela revient à construire la probabilité infinitésimale dP correspondant au fait que chaque
variables Xi appartient à l’intervalle [xi , xi + dxi ]. A partir de cette densité, on construit la vraisemblance 2
L égale à la valeur de la densité f obtenue en remplaçant les xi par les valeurs observées des variables Xi .
L (X1 , ..., Xn ) =
1
√
2πσ
n Y
n
i=1
(Xn − µ)2
exp −
2σ 2
!
(0.16)
Plutôt que d’avoir un produit, on préfère la log-vraisemblance (ou log-likelihood) :
!
X
n
1
(Xn − µ)2
log L (X1 , ..., Xn ) = n log √
+
−
2σ 2
2πσ
i=1
n
1
1 X
= n log √
− 2
(Xn − µ)2
2σ
2πσ
(0.17)
i=1
n
1
1 X
= n log √ − n log σ − 2
(Xn − µ)2
2σ
2π
i=1
(0.18)
On cherche maintenant à maximiser cette fonction par rapport à µ et σ. En dérivant et en cherchant à
annuler les dérivées partielles, on obtient le système d’équations suivant :

∂L



∂µ
∂L



∂σ
n
1 P
(Xi − µ)
=0
σ 2 i=1
n
n
1 P
= − + 3
(Xi − µ)2 = 0
σ σ i=1
=
(0.19)
On résoud d’abord la première équation puis la seconde pour obtenir :
n
n
i=1
i=1
1X
1X
µ =
Xi et (σ ∗ )2 =
(Xi − µ)2
n
n
∗
(0.20)
On retrouve la moyenne et la variance de l’échantillon (X1 , . . . , Xn ). La loi normale la plus appropriée pour
modéliser cet échantillon a pour paramètre µ∗ et σ ∗ . Et la loi la plus appropriée est celle qui maximise
l’expression (0.16). La figure 0.4 suggère que la courbe qui maximise cette expression est celle qui épouse
2. La vraisemblance est souvent noté L pour likelihood en anglais.
TABLE DES MATIÈRES
11
au mieux la forme de l’histogramme de l’échantillon 3 . Si cet histogramme est l’ensemble des couples
(tj , hj )1⩽j⩽k , on peut presque écrire que :
n
Y
i=1
f (Xi ) ≈
k
Y
[f (tj )]hj
(0.21)
j=1
Cette dernière expression montre que la fonction f doit éviter d’être nulle en tj lorsque hj n’est pas nulle.
C’est pour cela que la meilleure courbe f est celle qui épouse au mieux la forme de l’histogramme. Lorsqu’on
cherche les meilleurs paramètres d’une densité à l’aide de la méthode de l’estimateur de maximum de
vraisemblance, cela revient à choisir une forme de densité 4 et à chercher les paramètres qui font que cette
courbe épouse au mieux la vraie distribution des variables observées. L’histogramme est une approximation
de cette distribution.
Figure 0.4 : Ce graphique contient un histogramme qui approche la densité de l’échantillon (X1 , . . . , Xn ). La
première courbe en trait d’union est celle de la densité d’une loi normale de paramètres tirés au hasard. De manière
évidente, l’expression (0.16) calculée pour la courbe de ce graphique est inférieure au résultat obtenu pour une même
courbe mais centrée sur l’histogramme. Et le calcul du paragraphe 0.0.6 montre que la meilleure courbe épouse la
forme de l’histogramme.
L’estimateur du maximum de vraisemblance est ce qu’on appelle une méthode paramétrique. Il existe des
méthodes non paramétriques comme la méthode des noyaux qui ne fait pas d’hypothèse sur la forme de
la densité. D’autres méthodes encore ne s’intéressent qu’à une partie de la densité, plus précisément les
queues de distributions.
Par exemple, lors de la construction d’une plateforme pétrolière, il est important de connaître la hauteur
de la plus grande vague pour placer la plateforme juste au-dessus. Le coût de construction est plus élevé
lorsque la plateforme est surélevée mais elle est hors de portée des vagues qui ne peuvent plus l’emporter.
A partir de séries de mesures de hauteurs de vagues, les statisticiens s’intéressent non plus à la distribution
de cette hauteur mais à la distribution de la hauteur maximale, c’est-à-dire la probabilité d’événements
très rares.
La méthode de l’estimateur du maximum de vraisemblance n’est plus applicable lorsqu’on s’intéresse aux
queues de distributions. La densité calculée par ce moyen est proche de la véritable distribution à proximité
de la moyenne, là où il y a beaucoup de données. Mais elle est peu précise lorsqu’il y a peu de données
car, même si on fait des erreurs, elles sont peu nombreuses.
3. Un histogramme de l’échantillon (X1 , . . . , Xn ) est une liste de couples de valeurs (tj , hj )1⩽j⩽k où (tj )j est une suite
croissante de ℝ et hj est un nombre entier positif égal au nombre de variables Xi appartenant à l’intervalle [tj , tj+1 [.
Autrement dit :
n
1X
11
hj =
n i=1 {Xi ∈[tj , tj+1 [}
4. Une forme de densité ou plus exactement un modèle, loi normale, loi de Poisson, ... une loi dépendant d’un ou plusieurs
paramètres.
TABLE DES MATIÈRES
12
Les événements rares forment une branche à part dans la théorie statistique, elle prend de plus en plus
d’importance en assurance par exemple car on cherche de plus en plus à estimer la probabilité d’événements
rares comme les catastrophes naturels.
Pour aller plus loin :
L’expression (0.21) équivaut à la suivante :
(0.21) ⇐⇒
n
X
k
X
log f (Xi ) ≈
hi log f (tj )
i=1
(0.22)
j=1
Et si on note g la véritable densité de l’échantillon (X1 , . . . , Xn ), l’expression (0.22) converge vers une
limite lorsque n −→ ∞ :
n
1X
log f (Xi ) −→
n→∞
n
Z
i=1
g(x) log f (x)dx = 𝔼g (log f )
(0.23)
ℝ
R
Or l’expression − ℝ g(x) log f (x)dx est aussi appelée distance de Kullback-Leiber entre deux densités. La
densité f cherchée est celle qui minimise cette distance :
Problème 0.5 : distance de Kullback-Leiber
Soit l’ensemble RF des fonctions définies sur l’ensemble D ⊂ ℝ. Toute fonction f ∈ F vérifie ∀x ∈
D, f (x) > 0 et D f = 1. Soit g ∈ F . On cherche la fonction f ∗ solution du problème :
Z
∗
f = arg min −
g(x) log f (x)dx
f ∈F
D
Théorème 0.6 : distance de Kullback-Leiber
La solution du problème d’optimisation 0.5 est f ∗ = g.
On peut démontrer ce théorème lorsque l’ensemble
D est un sous-ensemble fini de ℕ. La fonction g est
P
définie par une liste de couple (j, gj )j∈D et j∈D gj = 1. C’est un histogramme. La fonction f est définie
P
de même : (j, fj )j∈D et j∈D fj = 1. La distance de Kullback-Leiber entre f et g s’écrit :
X
− gj log fj
(0.24)
j∈D
On cherche à démontrer que quelque soit la fonction f choisie, elle vérifie :
X
gj log fj ⩽
gj log gj
(0.25)
gj (log fj − log gj ) ⩽ 0
(0.26)
j∈D
⇐⇒
X
X
j∈D
j∈D
⇐⇒
X
j∈D
gj log
fj
⩽0
gj
(0.27)
TABLE DES MATIÈRES
Comme la fonction x −→ log x est concave et que
X
j∈D
P
j∈D gj
13
=1:
X
X
fj
fj
⩽
log gj
=
log fj ⩽ 0
gj log
gj
gj
j∈D
(0.28)
j∈D
Cette dernière inégalité suffit à démontrer que la disbribution qui minimise la distance de Kullback-Leiber
à une autre distribution est elle-même. Cette démonstration convient pour un ensemble D fini. Il reste à
l’adapter pour un ensemble dénombrable et plus généralement pour une densité définie sur ℝ, ce qui sort
du cadre de ce document 5 .
0.0.7
Second exemple : proportion de mâles chez les poissons
Un biologiste cherche à étudier la population d’une certaine espèce de poissons. Plus exactement, il voudrait
savoir quelle est la proportion de mâles et de femelles. Il a réussi à récupérer une base de données contenant
les tailles des poissons de cette espèce capturés par les pêcheurs sur une année entière. Malheureusement,
les pêcheurs n’ont pas distingué les mâles des femelles. Pour estimer cette proportion, le biologiste dispose
de deux informations :
1. La taille moyenne des mâles est différente de la taille moyenne des femelles, elle est même supérieure.
2. La taille des mâles est distribuée selon une loi normale, il en est de même pour les femelles.
A partir de ces deux informations (ou hypothèses), le biologiste suppose que la distribution des tailles des
poissons suit un mélange de loi normales :
αm
(x − µm )2
f (x) = √
exp −
2
2σm
2πσm
!
αf
(x − µf )2
+√
exp −
2σf2
2πσf
!
(0.29)
On sait d’après les hypothèses de modélisation que αm + αf = 1, αm > 0, αf > 0 et µm > µf . Il reste à
estimer ces paramètres. La méthode choisie est celle de l’estimateur du maximum de vraisemblance. On
note les tailles mesurées par les pêcheurs (X1 , . . . , XN ). On cherche donc à calculer :
α
∗
∗
, µ∗m , σm
, µ∗f , σf∗
=
arg max
α,µm ,σm ,µf ,σf
N Y
i=1
(Xi − µm )2
α
√
exp −
2
2σm
2πσm
!
(Xi − µf )2
1−α
√
exp −
2σf2
2πσf
+
!
(0.30)
On passe au logarithme, il faut donc maximiser la fonction g définie par :
N
X
"
(Xi − µm )2
α
exp −
g (α, µm , σm , µf , σf ) =
log √
2
2σm
2πσm
i=1
!
(Xi − µf )2
1−α
+√
exp −
2σf2
2πσf
!#
(Xi − µf )2
1−α
+√
exp −
2σf2
2πσf
!#
(0.31)
On note :
"
α
(Xi − µm )2
h (Xi , α, µm , σm , µf , σf ) = log √
exp −
2
2σm
2πσm
!
5. Cette démonstration utilise l’inégalité de Jensen. Si f est une fonction convexe sur ℝ et X une variable aléatoire réelle,
alors : 𝔼 (f (X)) ⩽ f (𝔼 (X)).
TABLE DES MATIÈRES
14
Afin de trouver le maximum de la fonction h, on calcule les dérivées de h par rapport à α, µm , σm , µf , σf :
∂g
(α, µm , σm , µf , σf ) =
∂α
1
N √
X
2πσm
∂g
(α, µm , σm , µf , σf ) =
∂σm
−µm )2
− (Xi2σ
2
m
i=1
N
X
∂g
(α, µm , σm , µf , σf ) =
∂µm
∂g
(α, µm , σm , µf , σf ) =
∂µf
exp
Xi −µm √ α
2
σm
2πσm
−
√ 1
2πσf
2
(Xi −µf )
exp − 2σ2
f
(0.32)
h (Xi , α, µm , σm , µf , σf )
−µm )2
exp − (Xi2σ
2
m
(0.33)
h (Xi , α, µm , σm , µf , σf )
i=1
2
(Xi −µf )
Xi −µf 1−α
√
exp
−
N
X
σ2
2σ 2
2πσ
f
f
f
h (Xi , α, µm , σm , µf , σf )
2
(Xi −µm )2
m)
N (Xi −µ
√ α
exp
−
−
X
3
2
σ
2σ
2πσ
(0.34)
i=1
m
i=1
N
X
i=1
(Xi −µf )
σf3
m
m
2
∂g
(α, µm , σm , µf , σf ) =
∂σf
√1−α
2πσf
√ α
2
2πσm
−µm )2
exp − (Xi2σ
2
m
h (Xi , α, µm , σm , µf , σf )
2
2
Xi −µf )
(Xi −µf )
(
1−α
exp − 2σ2
− √2πσ2 exp − 2σ2
f
f
h (Xi , α, µm , σm , µf , σf )
f
(0.35)
(0.36)
Annuler ces dérivées est impossible tout comme obtenir la solution exacte correspondant au maximum de
la fonction f . Il faut utiliser un algorithme approché, par exemple, une méthode d’optimisation de Newton.
Dans cet exemple, le calcul de la proportion des mâles et de femelles reposent sur le choix d’un modèle
pour la densité et d’une méthode numérique pour estimer ces paramètres.
Tout d’abord, on vérifie que la méthode numérique permettant d’estimer les paramètres du modèle (0.29)
permet effectivement de les retrouver dans une situation où ils sont connus. On simule donc un échantillon
de tailles de poissons générées aléatoirement selon la densité (0.29) avec des paramètres α, µm , σm , µf ,
σf puis on vérifie que l’algorithme 0.1 ou 0.3 convergent vers ces paramètres.
Cette première étape, si elle est réussie, valide en quelque sorte la méthodologie proposée. Il est alors
envisageable de considérer que les résultats obtenus avec des données réelles seront fiables.
Remarque 0.7 : Algorithme Expectation-Maximisation
Il existe un autre algorithme permettant d’estimer les paramètres d’une densité faite d’un mélange de
lois normales, c’est l’algorithme Expectation-Maximisation (ou EM) établi par Dempster (voir [?]). Cet
algorithme s’applique pour tout modèle contenant des informations cachées - pour cet exemple, c’est la
proportion de mâles et de femelles. Il est souvent préféré à un algorithme d’optimisation classique comme
ceux présentés dans ce chapitre : le paragraphe 0.0.12 montrera que le paramètre α liée à l’information
cachée fait de la résistance à l’algorithme 0.1.
0.0.8
Correction
0.0.9
Premier exemple, fonction quadratique
y2 + y
. Pour cela, on crée la
On cherche à tester l’algorithme BFGS pour la fonction f (x, y) = x4 + x3 +
100
classe optimisation_bfgs. Son constructeur prend entre autres comme paramètres f, derivee, args.
– f(x, ...) est la fonction à minimiser, cette fonction retourne la valeur de f au point x.
– derivee(x, ...) retourne un vecteur égal au gradient de la fonction f au point x.
– args est une liste d’arguments supplémentaires hormis x dont les fonctions f et derivee ont besoin.
Les deux fonctions f et derivee sont appelées par les méthodes erreur et gradient, elles-mêmes appelées
par la méthode optimise qui implémente l’algorithme BFGS 0.3. Toutes ces méthodes utilisent l’objet
TABLE DES MATIÈRES
15
array du module Numeric qui permet de stocker des vecteurs et des matrices. Le module Numeric définit
également toutes les opérations matricielles dont l’algorithme BFGS a besoin.
y2 + y
Pour appliquer l’algorithme BFGS sur la fonction f (x, y) = x4 + x3 +
, on définit les fonctions
100
suivantes :
def fonction (x, a,b,c) :
return x [0]**4 + a * x[0]**3 + b * x[1]**2 + c * x [1]
def derivee (x, a,b,c) :
return Num.array ( [4 * x[0]**3 + 3 * a * x[0]**2, b * 2 * x [1] + c] )
Puis on applique l’algorithme BFGS :
opt = optimisation_bfgs (fonction, derivee, (1,0.01,0.01))
x0 = Num.array ( [ 3, 4] )
x
= opt.optimise (x0)
Ces extraits ainsi que l’algorithme BFGS sont présents dans le programme qui suit.
# -*- coding: cp1252 -*import numpy as Num
import psyco
# pour les tableaux
class optimisation_bfgs (object) :
"""optimisation à l’aide de l’algorithme BFGS"""
def __init__ (self, f, derivee, args = None, \
epsilon = 0.1, erreur = 1e-5, maxiter = 100) :
"""initialisation
@param
f
fonction à minimiser --> f (x, args)
où x est un vecteur (Numeric.array)
@param
derivee
dérivée de f --> derivee (x, args)
@param
args
autres paramètres de la fonction
@param
epsilon
coefficient devant le gradient
@param
erreur
on s’arrête lorsque l’erreur ne décroît plus
@param
maxiter
nombre d’itérations maximum
"""
self._f
self._derivee
self._epsilon
self._erreur
self._maxiter
self._args
=
=
=
=
=
=
f
derivee
epsilon
erreur
maxiter
args
5
10
15
20
25
def erreur (self, x) :
"""calcule l’erreur"""
return self._f (x, *self._args)
30
def gradient (self, x) :
"""calcule le gradient"""
return self._derivee (x, *self._args)
def identite (self, dim) :
"""retourne la matrice identité"""
b
= Num.array ( [ [ 0 for i in xrange (0, dim) ] for j in xrange (0,dim) ] )
for i in xrange (0, dim) :
b [(i,i)] = 1
return b
def optimise (self, xO, classic = False, pr = True) :
35
40
TABLE DES MATIÈRES
"""optimisation selon l’algorithme BFGS,
x0 est le vecteur initiale, retourne la meilleure solution,
si pr == True, affiche des résultats intermédiaires,
classic == True, la matrice bt est mise à jour à chaque itération,
équivaut à une descente de gradient du premier degré"""
dim
stop
err
bt
id
t
iter
old
x
gt_
xt_
nbt
=
=
=
=
=
=
=
=
=
=
=
=
len (self.gradient (xO))
1e-12
self.erreur (xO)
self.identite (dim)
True
0
0
err * (1.0 + self._erreur * 2) * 2
xO
self.gradient (xO)
xO
0
while
(abs ((old - err) / err) > self._erreur or t == 0) and \
iter < self._maxiter :
if pr :
print "itération ", iter, " (", \
t,nbt, ") \t erreur : ", err, " (", old, ")"
iter
= iter + 1
gt
= self.gradient (x)
ct
= Num.dot (bt, gt)
e
= abs (err) * 2 + 1
eps = self._epsilon * 2
while e > err and eps > stop :
eps = eps / 2
xt = x - ct * eps
e
= self.erreur (xt)
if eps < 1e-12 and t > 0 :
bt = self.identite (dim)
if t == 0 : nbt += 1
else : nbt = 0
t = 0
else :
old
= err
x
= xt
err
= e
if not classic :
gt
= self.gradient (x)
dt
= gt - gt_
gbtg
= Num.dot (Num.transpose (gt), Num.dot (bt, gt))
gbtd
= Num.dot (Num.transpose (gt), Num.dot (bt, dt))
if (gbtg <= 0 or gbtd <= 0) and nbt < 2 :
if t == 0 : nbt += 1
else : nbt = 0
bt = self.identite (dim)
t = 0
else :
t
= t + 1
st
= xt - xt_
dtbtdt = Num.dot (Num.transpose (dt), Num.dot (bt, dt))
dtst
= Num.dot (Num.transpose (dt), st)
stdt
= Num.dot (Num.transpose (st), dt)
stst
= Num.outer (st, st)
stdtbt = Num.dot (Num.outer (st, dt), bt)
btdtst = Num.dot (bt, Num.outer (dt, st))
c
= 1.0 + dtbtdt / dtst
16
45
50
55
60
65
70
75
80
85
90
95
100
105
TABLE DES MATIÈRES
b
b
bt
17
= stst * (c / stdt)
-= (stdtbt + btdtst) / dtst
= bt + b
110
gt_ = gt
xt_ = x
return x
115
if __name__ == "__main__" :
psyco.full ()
def fonction (x, a,b,c) :
return x [0]**4 + a * x[0]**3 + b * x[1]**2 + c * x [1]
def derivee (x, a,b,c) :
return Num.array ( [4 * x[0]**3 + 3 * a * x[0]**2, b * 2 * x [1] + c] )
120
opt = optimisation_bfgs (fonction, derivee, (1,0.01,0.01), \
maxiter = 2000, epsilon = 0.2, erreur = 1e-10)
x0 = Num.array ( [ 3, 4] )
print "solution initiale : ", x0
x
= opt.optimise (x0, classic = False)
print "solution finale : ", x
125
Après exécution, on vérifie que la solution trouvée correspond bien à − 34 , − 21 . Pour comparer avec
l’algorithme d’optimisation du premier degré, on remplace la ligne suivante :
x
= opt.optimise (x0, classic = False)
Par :
x
= opt.optimise (x0, classic = True)
Alors qu’il faut moins d’une centaine d’itérations à l’algorithme BFGS pour converger la solution, il en
faut plus d’un millier à l’algorithme du premier ordre.
0.0.10
Second exemple, proportion de mâles et de femelles chez les poissons
Pour vérifier la pertinence d’une méthode numérique, on cherche d’abord à vérifier qu’elle marche bien sur
un échantillon (Xi )i dont on sait qu’il vérifie les hypothèses du problème à résoudre - la distribution des
Xi est un mélange de deux lois normales. Une fois cette première étape validée, il est alors utilisé sur des
données réelles ce qui ne sera pas fait ici.
0.0.11
Simulation d’une série (Xi )i
Tout d’abord, on cherche à simuler une série (Xi )1⩽i⩽N où chaque Xi suit une loi de densité (voir figure 0.5) :
!
!
(x − µf )2
α
(x − µm )2
1−α
exp −
+√
exp −
(0.37)
f (x) = √
2
2σm
2σf2
2πσm
2πσf
On choisi par exemple N = 10000, α = 0, 55, µm = 0, 40, µf = 0, 35, σm = 0, 020, σ = 0, 015. Les mâles
ont une taille moyenne de 40 cm et un écart-type de 2cm. Ceci signifie que 95% des mâles ont une taille
comprises entre 36cm et 44cm. Les femelles ont une taille moyenne de 40 cm et un écart-type de 1, 5 cm.
130
TABLE DES MATIÈRES
18
Figure 0.5 : Distribution des tailles de poissons selon le mélange de lois (0.37) avec pour paramètres α = 0, 55,
µm = 0, 40, µf = 0, 35, σm = 0, 020, σ = 0, 015.
Ceci signifie que 95% des femelles ont une taille comprise entre 32cm et 38cm. Pour cela, on applique
l’alogirthme suivant :
Algorithme 0.8 : simulation d’une variable selon un mélange de deux lois normales
On cherche à simuler une variable aléatoire X selon un mélange de deux lois normales :
!
!
(x − µf )2
α
(x − µm )2
1−α
X∼√
exp −
+√
exp −
2
2σm
2σf2
2πσm
2πσf
où α ∈ [0, 1], µm , µf ∈ ℝ, σm , σf > 0.
Etape A : choix de la composante normale
Soit U ∼ U [0, 1], U est une variable aléatoire uniforme sur [0, 1].
Etape B : simulation loi normale
On simule V selon une loi normale de moyenne nulle et de variance un. Autrement
dit, soit A, B deux variables générées selon une loi uniforme sur [0, 1] (voir [?]) :
p
V = −2 log A cos(2πB)
Etape C : construction de X
On calcule :
X = 11{U ⩽α} (σm V + µm ) + 11{U >α} (σf V + µf )
X est la valeur cherchée.
Pour obtenir la série (Xi )1⩽i⩽N , il suffit de calculer N valeurs avec l’algorithme 0.8.
0.0.12
Estimation des paramètres avec une méthode du premier degré
On implémente le premier algorithme 0.1 afin de retrouver les paramètres qui ont permis de simuler
l’échantillon (Xi )1⩽i⩽N . On cherche donc à maximiser la fonction g définie par l’expression (0.31) dont le
gradient est définie par les expressions (0.32) à (0.36).
Il n’est pas toujours possible de choisir des valeurs initiales pour l’algorithme d’optimisation. Toutefois,
dans le cas présent, les paramètres de la fonction g ont un sens presque physique. On peut donc choisir
TABLE DES MATIÈRES
19
des valeurs sensées pour la solution initiale de manière à accélérer la convergence de l’algorithme :
1
α=
2
r
µm
p
p
= 𝔼 (Xi ) + 𝕍 (Xi ) µf = 𝔼 (Xi ) − 𝕍 (Xi ) σm = σf =
𝕍 (Xi )
2
(0.38)
L’algorithme converge alors en une dizaine d’itérations vers le résultat de la figure 0.6. La log-vraisemblance
est très proche de celle obtenue avec le modèle initial et on remarque que pour cet exemple, elle est très
peu sensible au paramètre α et beaucoup plus aux autres paramètres puisque le paramètre α n’a pas varié
de sa valeur initiale 6 .
Figure 0.6 : Comparaison de la distribution qui a servi à générer les données (α = 0, 55, µm = 0, 4, µf = 0, 35,
σm = 0, 020, σ = 0, 15) avec la distribution qui a été estimée (α = 0, 50, µm = 0, 40, µf = 0, 35, σm = 0, 019,
σ = 0, 016).
Pour implémenter cet algorithme, on crée la classe poisson_loi. Cette classe permet de simuler un
échantillon de taille (méthodes simulation, méthodes generate), de calculer la log-vraisemblance pour un
échantillon (méthodes densite, log_densite, log_densite_list), de calculer le gradient pour un point x
(méthode gradient) ou pour un échantillon méthodes gradient_total). Enfin, cette classe implémtente
l’algorithme d’optimisation 0.1 par le biais de la méthode optimisation.
La partie principale du programme consiste tout d’abord à créer une instance de cette classe afin de générer
une série de 10000 tailles de poisson. Une seconde instance est ensuite créée qui estime ses coefficients à
l’aide de la méthode optimisation. Le résultat est affiché puis les densités sont comparées graphiquement
(méthode trace_densite).
# -*- coding: cp1252 -*import random
import math
class poisson_loi (object) :
"""loi de distribution de la taille des poissons"""
def __init__(self, alpha = 0.5, mm = 1, sm = 1, mf = 1, sf = 1) :
"""initialisation des paramètres de la loi"""
self.alpha = alpha
self.mm
= mm
self.sm
= sm
self.mf
= mf
self.sf
= sf
5
10
15
6. Le résultat est le même si la valeur initiale pour α est différente : lors de l’optimisation, ce paramètre évolue très peu.
TABLE DES MATIÈRES
def init (self, l) :
"""initialisation de la classe avec une liste de variables"""
m = 0
s = 0
for x in l :
m += x
s += x*x
m /= len (l)
s /= len (l)
s -= m*m
self.alpha = 0.5
self.sm
= s / 2
self.sf
= s / 2
self.sm
= math.sqrt (self.sm)
self.sf
= math.sqrt (self.sf)
self.mm
= m + self.sm * 2
self.mf
= m - self.sf * 2
def __str__(self) :
"""affichage"""
s = "classe poisson_loi\n"
s += "alpha = " + str (self.alpha) + "\n"
s += "moyenne male = " + str (self.mm) + "\n"
s += "sigma male = " + str (self.sm) + "\n"
s += "moyenne femelle = " + str (self.mf) + "\n"
s += "sigma femelle = " + str (self.sf) + "\n"
return s
def simulation (self) :
"""simule une taille de poisson"""
u = random.uniform (0,1)
v = random.gauss (0,1)
if u <= self.alpha :
return v * self.sm + self.mm
else :
return v * self.sf + self.mf
def generate (self,N) :
"""simule N tailles de poisson"""
return [ self.simulation () for i in xrange (0,N) ]
def trace_densite (self, autre = None) :
"""trace la courbe de la densité,
si autre != None, en trace une autre"""
xa = min (self.mm, self.mf) - 3.0 * max (self.sm, self.sf)
xb = max (self.mm, self.mf) + 3.0 * max (self.sm, self.sf)
n = 100
x = [ xa + (xb - xa) * i / n for i in xrange (0,n+1) ]
y = [ self.densite (xa + (xb - xa) * i / n) for i in xrange (0,n+1) ]
import pylab as pl
pl.plot ( x, y, "b" )
if autre != None :
xa = min (autre.mm, autre.mf) - 3.0 * max (autre.sm, autre.sf)
xb = max (autre.mm, autre.mf) + 3.0 * max (autre.sm, autre.sf)
n = 100
x = [ xa + (xb - xa) * i / n for i in xrange (0,n+1) ]
y = [ autre.densite (xa + (xb - xa) * i / n) for i in xrange (0,n+1) ]
pl.plot (x, y, "r")
pl.title ("Distribution des tailles de poisson")
pl.xlabel ("x")
pl.ylabel ("y")
20
20
25
30
35
40
45
50
55
60
65
70
75
pl.show()
80
TABLE DES MATIÈRES
def densite (self, x) :
"""calcule de la densité au point x"""
dpi = 1.0 / math.sqrt (math.pi * 2)
xm = (x - self.mm) ** 2 / (2 * self.sm * self.sm)
xm = math.exp (- xm)
xf = (x - self.mf) ** 2 / (2 * self.sf * self.sf)
xf = math.exp (- xf)
return self.alpha * xm / self.sm + (1.0 - self.alpha) * xf / self.sf
def log_densite (self, x) :
"""calcule de la log-densité au point x"""
try :
return math.log (self.densite (x))
except :
print "---------- erreur -------------------------------------------"
print x
return 0
def log_densite_list (self, l) :
"""calcule la somme des log-densités au point x de l"""
s = 0
for x in l :
s += self.log_densite (x)
s /= len (l)
return s
def gradient (self, x) :
"""calcul le gradient au point x, retourne un t-uple"""
unpim
= 1.0 / (math.sqrt (2 * math.pi) * self.sm)
unpif
= 1.0 / (math.sqrt (2 * math.pi) * self.sf)
expm
= math.exp ( - ( x - self.mm)**2 / (2 * (self.sm**2)))
expf
= math.exp ( - ( x - self.mf)**2 / (2 * (self.sf**2)))
grada
= unpim * expm - unpif * expf
gradmm = (x - self.mm) / (self.sm** 2) * self.alpha * unpim * expm
gradmf = (x - self.mf) / (self.sf** 2) * (1.0 - self.alpha) * unpif * expf
gradsm = self.alpha * unpim * (x - self.mm) ** 2 / (self.sm ** 3) - \
self.alpha * unpim / self.sm
gradsm *= expm
gradsf = (1.0 - self.alpha) * unpif * (x - self.mf) ** 2 / (self.sf ** 3) - \
self.alpha * unpif / self.sf
gradsf *= expf
f
= self.densite (x)
return (grada / f, gradmm / f, gradsm / f, gradmf / f, gradsf / f)
def gradient_total (self, l) :
"""calcul la somme des gradients pour tous les x de l"""
g = [ 0.0 for i in range (0,5) ]
for x in l :
(a,b,c,d,e) = self.gradient (x)
g [0] += a
g [1] += b
g [2] += c
g [3] += d
g [4] += e
for i in range (0,len (g)) :
g [i] /= len (l)
return ( g [0], g [1], g [2], g [3], g [4] )
def optimisation (self, l, epsilon = 0.001, erreur = 1e-5) :
"""recherche du maximum de la fonction f"""
self.init (l)
de
= self.log_densite_list (l)
print "première densité : ", de
dold = de / 2
nb
= 0
21
85
90
95
100
105
110
115
120
125
130
135
140
145
TABLE DES MATIÈRES
while abs (dold - de) / de > erreur :
(a,b,c,d,e) = self.gradient_total (l)
self.alpha
+= epsilon * a
self.mm
+= epsilon * b
self.sm
+= epsilon * c
self.mf
+= epsilon * d
self.sf
+= epsilon * e
dold = de
de
= self.log_densite_list (l)
nb += 1
print "itération ", nb, " densité ", de, " (", dold, ")
abs (dold - de) / de, " epsilon = ", epsilon
22
150
155
", \
if __name__ == "__main__" :
# création d’une instance de la classe
cl = poisson_loi (0.55, 0.40, 0.020, 0.35, 0.015)
print cl
# affichage
#cl.trace_densite ()
# courbe densité
160
165
l = cl.generate (10000)
cl2 = poisson_loi ()
print "-----------------------------------------------------------"
print "log densité maximale ", cl.log_densite_list (l)
(a,b,c,d,e) = cl.gradient_total (l)
print "gradient idéal ", (a,b,c,d,e)
print "-----------------------------------------------------------"
(a,b,c,d,e) = cl2.gradient_total (l)
print "gradient avant", (a,b,c,d,e)
cl2.optimisation (l)
(a,b,c,d,e) = cl2.gradient_total (l)
print "gradient après ", (a,b,c,d,e)
print "-----------------------------------------------------------"
print cl2
cl2.trace_densite (cl)
print "log vraisemblance : ", cl2.log_densite_list (l)
0.0.13
Estimation des paramètres avec une méthode du second degré
Le second programme utilise l’algorithme BFGS pour déterminer le maximum de vraisemblance (voir
figure 0.7). Cette méthode du second degré permet de corriger le fait que le gradient par rapport au
paramètre α est plus faible que les dérivées partielles par rapport aux autres coefficients. On trouve cette
fois-ci des valeurs proches du modèle qui a permis de simuler les observations.
Ces méthodes sont très calculatoires et pour accélérer la vitesse de convergence de l’algorithme, il est
possible d’utiliser le module pysco en utilisant ces deux lignes.
import psyco
psyco.full ()
La vitesse du programme est multipliée par trois ou quatre lorsque celui-ci passe la plus grande partie de
son temps à faire des calculs.
# -*- coding: cp1252 -*import poisson
#import scipy.optimize.lbfgsb as Opt
# optimisation
import bfgs
# optimisation
170
175
180
TABLE DES MATIÈRES
23
Figure 0.7 : Comparaison de la distribution qui a servi à générer les données (α = 0, 55, µm = 0, 4, µf = 0, 35,
σm = 0, 020, σ = 0, 15) avec la distribution qui a été estimée (α = 0, 54, µm = 0, 40, µf = 0, 35, σm = 0, 020,
σ = 0, 015).
import numpy as Num
import psyco
# pour les tableaux
def fonction_bfgs (x, cl, l) :
"""fonction retournant l’opposé de la log-vraisemblance
de l’instance cl, fonction à minimiser"""
cl.set (x)
f = - cl.log_densite_list (l)
#print f, "\t", x
return f
5
10
15
def fonction_derivee_bfgs (x, cl, l) :
"""fonction retournant l’opposé de la log-vraisemblance
de l’instance cl, fonction à minimiser"""
cl.set (x)
f
= cl.gradient_total (l)
return - Num.array (f)
class poisson_loi_bfgs (poisson.poisson_loi) :
"""loi de distribution de la taille des poissons,
optimisation à l’aide de l’algorithme BFGS"""
20
25
def __init__(self, alpha = 0.5, mm = 1, sm = 1, mf = 1, sf = 1) :
"""initialisation des paramètres de la loi"""
poisson.poisson_loi.__init__(self, alpha, mm, sm, mf, sf)
30
def set (self, x) :
"""initialisation avec un tableau"""
self.alpha
= x [0]
self.mm
= x [1]
self.sm
= abs (x [2])
self.mf
= x [3]
self.sf
= abs (x [4])
def get (self) :
"""retourne un tableau contenant les paramètres"""
return Num.array ( (self.alpha, self.mm, self.sm, self.mf, self.sf) )
def __str__(self) :
"""affichage"""
s = "classe poisson_loi BFGS\n"
s += "alpha = " + str (self.alpha) + "\n"
35
40
45
TABLE DES MATIÈRES
s += "moyenne male = " + str (self.mm) + "\n"
s += "sigma male = " + str (self.sm) + "\n"
s += "moyenne femelle = " + str (self.mf) + "\n"
s += "sigma femelle = " + str (self.sf) + "\n"
return s
def optimisation (self, l, epsilon = 0.001) :
"""recherche du maximum de la fonction f"""
self.init (l)
x0
= self.get ()
print x0
opt
= bfgs.optimisation_bfgs (fonction_bfgs, \
fonction_derivee_bfgs, \
args = (self, l))
x = opt.optimise (x0)
#x
= bfgs.Opt.fmin_l_bfgs_b ( fonction_bfgs, \
#
x0, \
#
fonction_derivee_bfgs, \
#
args = (self, l))
self.set (x)
print "optimisation terminée"
print "valeur maximale : ", self.log_densite_list (l)
print "message ", d
24
50
55
60
65
70
if __name__ == "__main__" :
psyco.full ()
# création d’une instance de la classe
cl = poisson.poisson_loi (0.55, 0.40, 0.020, 0.35, 0.015)
print cl
# affichage
#cl.trace_densite ()
# courbe densité
l = cl.generate (10000)
cl2 = poisson_loi_bfgs ()
print "-----------------------------------------------------------"
print "log densité maximale ", cl.log_densite_list (l)
(a,b,c,d,e) = cl.gradient_total (l)
print "gradient idéal ", (a,b,c,d,e)
print "-----------------------------------------------------------"
(a,b,c,d,e) = cl2.gradient_total (l)
print "gradient avant", (a,b,c,d,e)
cl2.optimisation (l)
(a,b,c,d,e) = cl2.gradient_total (l)
print "gradient après ", (a,b,c,d,e)
print "-----------------------------------------------------------"
print cl2
cl2.trace_densite (cl)
print "log vraisemblance : ", cl2.log_densite_list (l)
75
80
85
90
95
Index
H
histogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
A
Algorithme
algorithme BFGS . . . . . . . . . . . . . . . . . . . . . . . . . 6
descente de gradient de Newton . . . . . . . . . . . 3
optimisation stochastique . . . . . . . . . . . . . . . . . 8
simulation d’une variable selon un mélange
de deux lois normales . . . . . . . . . . . . . . . . 18
apprentissage
second ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
I
indépendance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
inégalité de Jensen . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
J
Jensen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
K
Kullback-Leiber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
B
BFGS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
L
likelihood . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
log-vraisemblance. . . . . . . . . . . . . . . . . . . . . . . . .10, 19
C
Cauchy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5
condition d’arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
vitesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
critère
Cauchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
M
méthode
non-paramétrique . . . . . . . . . . . . . . . . . . . . . . . . 11
noyaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
paramétrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
second ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
module
math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Numeric . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
psyco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 22
random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
moyenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
D
descente
gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
DFP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
distance
Kullback-Leiber . . . . . . . . . . . . . . . . . . . . . . . . . . 12
distribution
queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
N
Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
E
écart-type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
échantillon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
EM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
emv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
énénement rare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
espérance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
estimateur du maximum de vraisemblance . 9, 13
Expectation-Maximisation. . . . . . . . . . . . . . . . . . . .14
O
optimisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2
BFGS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
DFP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
stochastique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8
valeurs initiale . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
ordre
méthode du second ordre . . . . . . . . . . . . . . . . . . 5
F
fonction quadratique . . . . . . . . . . . . . . . . . . . . . . . . . . 9
G
gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
conjugué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
descente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2, 3
stochastique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7
P
poisson. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13
Problème
distance de Kullback-Leiber . . . . . . . . . . . . . . 12
25
Index
programmes, exemples
psyco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
algorithme BFGS . . . . . . . . . . . . . . . . . . . . . . . 15
BFGS, scipy . . . . . . . . . . . . . . . . . . . . . . . . . 15, 17
déterminer la taille des poissons . . . . . . . . . 22
simulation de tailles de poissons . . . . . . . . . 19
Q
quasi-Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
R
références
Bottou1991 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5, 8
Broyden1967 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Davidon1959 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Dempster1977. . . . . . . . . . . . . . . . . . . . . . . . . . . .14
Driancourt1996 . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Fletcher1963 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Fletcher1993 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Moré1977 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Robert1996 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
remarque
Algorithme Expectation-Maximisation . . . 14
S
simulation
mélange de lois normales . . . . . . . . . . . . . . . . . 17
stochastique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 8
T
Théorème
convergence de la méthode de Newton
(Bottou1991) . . . . . . . . . . . . . . . . . . . . . . . . . 4
distance de Kullback-Leiber . . . . . . . . . . . . . . 12
V
vague . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
variables
indépendantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
variance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
vraisemblance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9, 19
Liens
numéros
Algorithme
0.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
0.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
0.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
0.8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
démonstration
théorème 0.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Problème
0.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Théorème
0.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
0.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
26
Table des matières
0.0.1
0.0.2
0.0.3
0.0.4
0.0.5
0.0.6
0.0.7
0.0.8
0.0.9
0.0.10
0.0.11
0.0.12
0.0.13
Index
Enoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme et convergence . . . . . . . . . . . . . . . . . . . . . . . .
Méthode du second ordre . . . . . . . . . . . . . . . . . . . . . . . .
Minimisation avec gradient stochastique . . . . . . . . . . . . . . . .
Premier exemple : optimisation d’une fonction quadratique . . . . .
Court rappel sur l’estimateur du maximum de vraisemblance . . . .
Second exemple : proportion de mâles chez les poissons . . . . . . . .
Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Premier exemple, fonction quadratique . . . . . . . . . . . . . . . . .
Second exemple, proportion de mâles et de femelles chez les poissons
Simulation d’une série (Xi )i . . . . . . . . . . . . . . . . . . . . . . .
Estimation des paramètres avec une méthode du premier degré . . .
Estimation des paramètres avec une méthode du second degré . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
5
7
9
9
13
14
14
17
17
18
22
25