Post on 03-Jul-2015
Programmation Dynamique
Mise en œuvre et application à des problèmes en TAL
Sébastien Combéfis
23 décembre 2009
Plan
1 Introduction
Le problème du Change
Programmation dynamique
2 Application à des problèmes en TAL
Algorithme de Viterbi
Distance d’édition
Algorithme CKY
2
Algorithme naif pour le problème du change
Il faut rendre une certaine quantité d’argent M sous forme depièces, tout en rendant un minimum de pièces
Un algorithme naif utilisé par la plupart des caissiers
Input : M une quantité d’argent positiveOutput : Liste de pièces à rendre pour former M, tel que le
nombre de pièces soit minimalL← 〈〉1
while M > 0 do2
c ← La pièce de plus grande valeur tel que c ≤ M3
L← L + 〈c〉4
M ← M − c5
return L6
3
Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 40
2520105
⊲
4
Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 15
2520105⊲
25
4
Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 5
2520105⊲
25 10
4
Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 0
2520105
25 10 5
4
Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 0
2520105
25 10 5
Ce n’est pas la solution optimale !
L’algorithme proposé n’est pas correct !
4
Algorithme brute-force
Pour être sûr d’avoir la solution optimale, on peut explorertoutes les solutions possibles
40
15
20
30
35
0
5
10
15
20
25
30
0
5
10
15
20
25
0
5
10
15
20
0
5
10
15
0
5
10
0
5
0
5
Algorithme brute-force
On choisit ensuite la solution qui qui coute le moins cher (ouune des solutions les moins chères s’il y a plusieurs possibilités)
40
15
20
30
35
0
5
10
15
20
25
30
0
5
10
15
20
25
0
5
10
15
20
0
5
10
15
0
5
10
0
5
0
5
Programmation dynamique I
Résoudre un problème en s’attaquant à des sous-problèmessimilaires au problème initial et plus simples à résoudre
Éviter de calculer plusieurs fois la même chose en exploitant lamémoization
Principe d’optimalité de Bellman
Une solution optimale d’une instance du problème peut toujoursêtre obtenue à partir de solutions optimales aux sous-problèmes
6
Programmation dynamique II
Contrairement à l’approche « Diviser pour Régner » , lessous-problèmes peuvent se superposer
Méthode ascendante, on commence par résoudre les petitssous-problèmes pour obtenir une solution au problème initial
Diviser pour régner Programmation dynamique
7
Retour sur le problème du change
Définition récursive du problème :
ChangeM = min
ChangeM−5 + 1ChangeM−10 + 1ChangeM−20 + 1ChangeM−25 + 1
Pour trouver le nombre optimal de pièces sommant à M, onessaie toutes les possibilités et on prend la meilleure
8
Algorithme récursif
Une version récursive de l’algorithme :
Input : M une quantité d’argent positiveOutput : Nombre minimal de pièces à rendre pour former M
if M = 0 then1
return 02
best ← +∞3
foreach c ∈ Coins do4
if M ≥ c then5
n← Change(M − c)6
if n + 1 < best then7
best ← n + 18
return best9
9
Algorithme récursif
Une version récursive de l’algorithme :
minc∈Coins
Change(M − c)
Input : M une quantité d’argent positiveOutput : Nombre minimal de pièces à rendre pour former M
if M = 0 then1
return 02
best ← +∞3
foreach c ∈ Coins do4
if M ≥ c then5
n← Change(M − c)6
if n + 1 < best then7
best ← n + 18
return best9
9
Exemple et complexité
L’algorithme n’est pas du tout efficace, de nombreuxsous-problèmes sont exécutés plusieurs fois
40
35 30 20 15
30 25 15 10 25 20 10 5 15 10 0 −5 10 5 −5 −10
L’algorithme fonctionne de manière descendante
Algorithme de complexité temporelle O(Md)
10
Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
Input : M une quantité d’argent positiveOutput : Nombre minimal de pièces à rendre pour former M
tab ← new Array [M + 1]1
tab[0]← 02
for m← 1 to M do3
tab[m]← +∞4
foreach c ∈ Coins do5
if m ≥ c then6
if tab[m − c] + 1 < tab[m] then7
tab[m]← tab[m − c] + 18
return tab[M]9
11
Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
minc∈Coins
tab[m− c]
Input : M une quantité d’argent positiveOutput : Nombre minimal de pièces à rendre pour former M
tab ← new Array [M + 1]1
tab[0]← 02
for m← 1 to M do3
tab[m]← +∞4
foreach c ∈ Coins do5
if m ≥ c then6
if tab[m − c] + 1 < tab[m] then7
tab[m]← tab[m − c] + 18
return tab[M]9
11
Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . +∞
m 40
c
12
Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . +∞
m 40
c 5
12
Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 3
m 40
c 10
12
Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 3
m 40
c 20
12
Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 2
m 40
c 25
12
Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 2
m
c
L’algorithme fonctionne de manière ascendante
Algorithme de complexité temporelle O(Md)
Il exploite le fait que la valeur ChangeM ne dépend que decelles de Changem pour m < M
12
Comparaison des complexités
0
5
10
15
20
25
30
35
0 10 20 30 40 50
Nombre d’opérations élémentaires en fonction de M
ChangeRecChangeDP
Version récursive en O(Md)Version programmation dynamique en O(Md)
13
Obtenir les dénominations des pièces
Il suffit d’ajouter un tableau qui stocke une pièce :
Input : M une quantité d’argent positiveOutput : Nombre minimal de pièces à rendre pour former M
tab ← new Array [M + 1]1
tab[0]← 02
denom ← new Array [M + 1]3
for m← 1 to M do4
tab[m]← +∞5
foreach c ∈ Coins do6
if m ≥ c then7
if tab[m − c] + 1 < tab[m] then8
tab[m]← tab[m − c] + 19
denom[m] ← c10
return tab[M]11
14
Plan
1 Introduction
Le problème du Change
Programmation dynamique
2 Application à des problèmes en TAL
Algorithme de Viterbi
Distance d’édition
Algorithme CKY
15
Plan
1 Introduction
Le problème du Change
Programmation dynamique
2 Application à des problèmes en TAL
Algorithme de Viterbi
Distance d’édition
Algorithme CKY
16
Algorithme de Viterbi
Utilisé pour résoudre le problème du décodage sur un modèlede Markov caché (HMM)
Problème du décodage
Soit un HMM M = (Q,Σ, π, a, b) et une séquence d’observationsO = 〈o0, o1, · · · , oT−1〉, le problème du décodage consiste àtrouver la séquence d’état q = 〈q0, q1, · · · , qT−1〉 la plus probablequi a généré la séquence d’observations O.
17
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS · bS,il
18
Tagging basé sur les HMMs
S
V C
0
0.7
0.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS · bS,il · aS,V
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS · bS,il · aS,V · bV ,combat
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS ·bS,il ·aS,V ·bV ,combat ·aV ,C
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS · bS,il · aS,V · bV ,combat ·aV ,C · bC ,Florence
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3,0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS · bS,il · aS,V · bV ,combat ·aV ,C · bC ,Florence · ωC
18
Tagging basé sur les HMMs
S
V C
0
0.70.10.2
0.1
0.4
0.1
0.2
0.3
P(il) = 0.5P(combat) = 0.1P(Florence) = 0.4
P(il) = 0.1P(combat) = 0.8P(Florence) = 0.1
P(il) = 0.3P(combat) = 0.1P(Florence) = 0.6
Q = (S,V ,C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
O = 〈il , combat,Florence〉
q = ?
P(S,V ,C ; il , combat,Florence)
= πS · bS,il · aS,V · bV ,combat ·aV ,C · bC ,Florence · ωC
= 0.016128
18
Définition récursive du problème
δt(i) est la meilleure probabilité d’être sur l’état i au temps t
i
t
i − 1
i
i + 1
t − 1
. . .
. . .
. . .
t − 2
δt−1(i − 1)
δt−1(i + 1)
δt−1(i)
ai−1,i
ai ,i
ai+1,i
19
Définition récursive du problème
δt(i) est la meilleure probabilité d’être sur l’état i au temps t
i
t
i − 1
i
i + 1
t − 1
. . .
. . .
. . .
t − 2
δt−1(i − 1)
δt−1(i + 1)
δt−1(i)
ai−1,i
ai ,i
ai+1,i
δt(i) = maxj∈Q
(
δt−1(j) · aj,i · bi ,ot
)
19
Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
Input : M = (Q,Σ, π, ω, a, b),O = 〈o0, o1, · · · , oT−1〉Output : Probabilité de la séquence d’états la + probable pour Ofor i ← 0 to n − 1 do1
δ0(i)← πi · bi ,o02
for t ← 1 to T − 1 do3
for i ← 0 to n− 1 do4
δt(i)← −∞5
for j ← 0 to n− 1 do6
if δt−1(j) · aj,i · bi ,ot > δt(i) then7
δt(i)← δt−1(j) · aj,i · bi ,ot8
return maxj∈Q
(
ωj · δT−1(j))
9
20
Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
maxj∈Qδt−1(j) · aj,i · bi ,ot
Input : M = (Q,Σ, π, ω, a, b),O = 〈o0, o1, · · · , oT−1〉Output : Probabilité de la séquence d’états la + probable pour Ofor i ← 0 to n − 1 do1
δ0(i)← πi · bi ,o02
for t ← 1 to T − 1 do3
for i ← 0 to n− 1 do4
δt(i)← −∞5
for j ← 0 to n− 1 do6
if δt−1(j) · aj,i · bi ,ot > δt(i) then7
δt(i)← δt−1(j) · aj,i · bi ,ot8
return maxj∈Q
(
ωj · δT−1(j))
9
20
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 × × ×12∗
21
Exemple et complexité
Soit la séquence d’observations O = 〈il, combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×12∗
δ0(S) = πS · bS,il = 0.3δ0(V ) = πV · bV ,il = 0.15δ0(C) = πC · bC ,il = 0.05
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 V
2∗
δ1(S) = max
δ0(S) · aS,S · bS,combat = 0δ0(V ) · aV ,S · bS,combat = 0.003
δ0(C) · aC ,S · bS,combat = 0.0005
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 V S
2∗
δ1(V ) = max
δ0(S) · aS,V · bV ,combat = 0.168
δ0(V ) · aV ,V · bV ,combat = 0.012δ0(C) · aC ,V · bV ,combat = 0.008
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 0.006 V S V
2∗
δ1(C) = max
δ0(S) · aS,C · bC ,combat = 0.003δ0(V ) · aV ,C · bC ,combat = 0.006
δ0(C) · aC ,C · bC ,combat = 0.0015
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 0.006 V S V
2 0.01344 V
∗
δ2(S) = max
δ1(S) · aS,S · bS,Florence = 0δ1(V ) · aV ,S · bS,Florence = 0.01344
δ1(C) · aC ,S · bS,Florence = 0.00024
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 0.006 V S V
2 0.01344 0.00168 V V
∗
δ2(V ) = max
δ1(S) · aS,V · bV ,Florence = 0.00021δ1(V ) · aV ,V · bV ,Florence = 0.00168
δ1(C) · aC ,V · bV ,Florence = 0.00012
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 0.006 V S V
2 0.01344 0.00168 0.04032 V V V
∗
δ2(C) = max
δ1(S) · aS,C · bC ,Florence = 0.00018δ1(V ) · aV ,C · bC ,Florence = 0.04032
δ1(C) · aC ,C · bC ,Florence = 0.00108
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 0.006 V S V
2 0.01344 0.00168 0.04032 V V V
∗ 0.005376 0.000504 0.016128
ω = (0.4, 0.3, 0.4)
δ∗ = ωC · δ2(C)
φ2(C) = V
φ1(V ) = S ⇒ q = 〈S,V ,C〉
21
Exemple et complexité
Soit la séquence d’observations O = 〈il , combat,Florence〉
t δt(S) δt(V ) δt(C) φt(S) φt(V ) φt(C)
0 0.3 0.15 0.05 × × ×1 0.003 0.168 0.006 V S V
2 0.01344 0.00168 0.04032 V V V
∗ 0.005376 0.000504 0.016128
ω = (0.4, 0.3, 0.4)
δ∗ = ωC · δ2(C)
φ2(C) = V
φ1(V ) = S ⇒ q = 〈S,V ,C〉
Complexité temporelle O(Tn2)
21
Plan
1 Introduction
Le problème du Change
Programmation dynamique
2 Application à des problèmes en TAL
Algorithme de Viterbi
Distance d’édition
Algorithme CKY
22
Distance d’édition
Utilisée pour mesurer la distance entre deux séquences
Opération d’édition
Une opération d’édition est une (x , y) ∈ (Σ ∪ {−})× (Σ ∪ {−})
x = − et y ∈ Σ (insertion)
x ∈ Σ et y = − (délétion)
x , y ∈ Σ et x 6= y (substitution)
Distance d’édition
Soient deux séquences a et b et une fonction de coutw : (Σ ∪ {−})× (Σ ∪ {−})→ R
La distance d’édition dw (a, b) = minS(w(S) | a⇒S b) avec S uneséquence d’opérations d’édition
23
Spellcheck basé sur la distance d’édition
MITSY
24
Spellcheck basé sur la distance d’édition
MITSY
EMITSY(−,E )
24
Spellcheck basé sur la distance d’édition
MITSY
EMITSY
EDITSY
(−,E )
(M,D)
24
Spellcheck basé sur la distance d’édition
MITSY
EMITSY
EDITSY
EDITS
(−,E )
(M,D)
(Y ,−)
24
Spellcheck basé sur la distance d’édition
MITSY
EMITSY
EDITSY
EDITS
(−,E )
(M,D)
(Y ,−)
-MITSY
EDITS-
24
Définition récursive du problème
d(ε, ε) = 0 (ε est la chaine vide)
d(s, ε) = d(ε, s) = |s| (|s | est la longueur de s)
d(s1 · · · sn, t1 · · · tm) =
min
d(s1 · · · sn, t1 · · · tm−1) + 1 (insertion)d(s1 · · · sn−1, t1 · · · tm) + 1 (délétion)d(s1 · · · sn−1, t1 · · · tm−1) + (1− δsntm) (substitution)
s1 · · · sn tm
t1 · · · tm−1 tm
s1 · · · sn−1 sn
t1 · · · tm
s1 · · · sn−1 sn
t1 · · · tm−1 tm
25
Algorithme en programmation dynamique
Calcul de la distance d’édition entre les chaines s et t avec|s| = n et |t| = m et fonction de cout w = 1
Utilisation d’une matrice M de taille (n + 1)× (m + 1)
M[i , j] contient la distance d’édition pour passer du mots1 · · · si ou mot t1 · · · tj
M[0, 0] = 0 d(ε, ε) = 0
M[i , 0] = i d(s1 · · · si , ε) = i
M[0, j] = j d(ε, t1 . . . tj) = j
M[i , j] = min
M[i , j − 1] + 1M[i − 1, j] + 1M[i − 1, j − 1] + (1 − δsi tj
)
26
Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
Input : s = 〈s1 · · · sn〉 et t = 〈t1 · · · tm〉Output : Distance d’édition d(s, t)M ← new Array [n + 1][m + 1]1
for i ← 0 to n do M[i ][0]← i2
for j ← 0 to m do M[0][j]← j3
for i ← 1 to n do4
for j ← 1 to m do5
M[i ][j]← M[i ][j − 1] + 16
if M[i − 1][j] + 1 < M[i ][j] then7
M[i ][j]← M[i − 1][j] + 18
if M[i − 1][j − 1] + (1− δsi sj) < M[i ][j] then9
M[i ][j]← M[i − 1][j − 1] + (1− δxi yj)10
return M[m][n]11
27
Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
min
M[i ][j − 1] + 1M[i − 1][j]M[i − 1][j − 1] + (1− δsi tj
)
Input : s = 〈s1 · · · sn〉 et t = 〈t1 · · · tm〉Output : Distance d’édition d(s, t)M ← new Array [n + 1][m + 1]1
for i ← 0 to n do M[i ][0]← i2
for j ← 0 to m do M[0][j]← j3
for i ← 1 to n do4
for j ← 1 to m do5
M[i ][j]← M[i ][j − 1] + 16
if M[i − 1][j] + 1 < M[i ][j] then7
M[i ][j]← M[i − 1][j] + 18
if M[i − 1][j − 1] + (1− δsi sj) < M[i ][j] then9
M[i ][j]← M[i − 1][j − 1] + (1− δxi yj)10
return M[m][n]11
27
Exemple et complexité
ε P E T I Tε 0 1 2 3 4 5G 1E 2N 3T 4I 5L 6
ε P E T I Tε ← ← ← ← ←G ↑E ↑N ↑T ↑I ↑L ↑
28
Exemple et complexité
ε P E T I Tε 0 1 2 3 4 5G 1 1
E 2N 3T 4I 5L 6
ε P E T I Tε ← ← ← ← ←G ↑ տE ↑N ↑T ↑I ↑L ↑
M[1][1] =
M[1][0] + 1M[0][1] + 1M[0][0] + (1− δGP)
G → P =
(G → ε) + 1(ε→ P) + 1(ε→ ε) + 1
28
Exemple et complexité
ε P E T I Tε 0 1 2 3 4 5G 1 1 2 3 4 5E 2 2 1 2
N 3T 4I 5L 6
ε P E T I Tε ← ← ← ← ←G ↑ տ տ← տ← տ← տ←E ↑ տ↑ տ ←N ↑T ↑I ↑L ↑
M[2][3] =
M[2][2] + 1
M[1][3] + 1M[1][2] + (1− δET )
GE → PET =
(GE → PE ) + 1(G → PET ) + 1(G → PE ) + 1
28
Exemple et complexité
ε P E T I Tε 0 1 2 3 4 5G 1 1 2 3 4 5E 2 2 1 2 3 4N 3 3
T 4I 5L 6
ε P E T I Tε ← ← ← ← ←G ↑ տ տ← տ← տ← տ←E ↑ տ↑ տ ← ← ←N ↑ տ↑T ↑I ↑L ↑
M[3][1] =
M[3][0] + 1M[2][1] + 1
M[2][0] + (1− δNP)GEN → P =
(GEN → ε) + 1(GE → P) + 1(GE → ε) + 1
28
Exemple et complexité
ε P E T I Tε 0 1 2 3 4 5G 1 1 2 3 4 5E 2 2 1 2 3 4N 3 3 2 2 3 4T 4 4 3 2 3 3I 5 5 4 3 2
L 6
ε P E T I Tε ← ← ← ← ←G ↑ տ տ← տ← տ← տ←E ↑ տ↑ տ ← ← ←N ↑ տ↑ ↑ տ տ← տ←T ↑ տ↑ ↑ տ տ← տI ↑ տ↑ ↑ ↑ տL ↑
M[5][4] =
M[5][3] + 1M[4][4] + 1M[4][3] + (1− δII)
GENTI → PETI =
(GENTI → PET ) + 1(GENT → PETI + 1(GENT → PET ) + 0
28
Exemple et complexité
ε P E T I Tε 0 1 2 3 4 5G 1 1 2 3 4 5E 2 2 1 2 3 4N 3 3 2 2 3 4T 4 4 3 2 3 3I 5 5 4 3 2 3L 6 6 5 4 3 3
ε P E T I Tε ← ← ← ← ←G ↑ տ տ← տ← տ← տ←E ↑ տ↑ տ ← ← ←N ↑ տ↑ ↑ տ տ← տ←T ↑ տ↑ ↑ տ տ← տI ↑ տ↑ ↑ ↑ տ ←L ↑ տ↑ ↑ ↑ ↑ տ
GENTIL
PE-TITComplexité temporelle O(nm)
28
Plan
1 Introduction
Le problème du Change
Programmation dynamique
2 Application à des problèmes en TAL
Algorithme de Viterbi
Distance d’édition
Algorithme CKY
29
Algorithme CKY
Analyseur syntaxique basé sur une approche bottom-up
S’applique aux grammaires hors-contexte (type 2 Chomsky)données en forme normale de Chomsky (CNF). Les règles sontde deux formes :
S → AB
S → a
Calcule toutes les interprétations possibles de toutes lessous-séquences de la séquence d’entrée
30
Analyse syntaxique d’une phrase
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN La fille aime le mauve
Det N V Det N
31
Analyse syntaxique d’une phrase
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN La fille aime le mauve
Det N V Det N
X1
31
Analyse syntaxique d’une phrase
S → SN SV
S → SN V
SN→ Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN La fille aime le mauve
Det N V Det N
SN SN
31
Analyse syntaxique d’une phrase
S → SN SV
S→ SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN La fille aime le mauve
Det N V Det N
SN SN
S
31
Analyse syntaxique d’une phrase
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV→ V SN
SV → X2 SNP
X2 → V SN La fille aime le mauve
Det N V Det N
SN SN
SV
31
Analyse syntaxique d’une phrase
S→ SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN La fille aime le mauve
Det N V Det N
SN SN
SV
S
31
Définition récursive du problème I
Éviter de réanalyser plusieurs fois les mêmes sous-séquences
Chaine abc · · · à analyser de la forme 0 a 1 b 2 c 3 · · ·
Tableau carré contenant n lignes et colonnes (n = longueur dela chaine)
1 2 3 · · ·012...
L’entrée (i , j) correspond à lasous-chaine commençant en i
et se finissant en j
32
Définition récursive du problème II
Mot à analyser : w1w2 · · ·wn
Cas de base : Mot wi , P[i − 1][i ] ∪= {S}, avec S → wi
Cas récursif : Sous-chaine wi , · · · ,wj , il faut analyser toutesles découpes de la sous-chaine : wi , · · · ,wk , · · · ,wj
33
Algorithme en programmation dynamique
Pour une grammaire G = 〈N,Σ,P,S〉, tester si une chainew = w1, · · · ,wn appartient à L(G)
Input : G = 〈N,Σ,P,S〉 et w = w1, · · · ,wn
Output : w ∈ L(G)P ← new Array [n + 1][n + 1]1
for i ← 1 to n do2
if X → wi ∈ P then3
P[i − 1][i ]← P[i − 1][i ] ∪ {X}4
for j ← 1 to n do5
for i ← j − 2 downto 0 do6
for k ← i + 1 to j − 1 do7
if X → A B ∈ G ∧ A ∈ P[i ][k] ∧ B ∈ P[k][j] then8
P[i ][j]← P[i ][j] ∪ {X}9
return S ∈ P[n + 1][n + 1]10
34
Algorithme en programmation dynamique
Pour une grammaire G = 〈N,Σ,P,S〉, tester si une chainew = w1, · · · ,wn appartient à L(G)
On cherche les décompositions dewi+1, · · · ,wj avec S → A B dansla grammaire et A ⇒ wi+1; · · ·wk
et B ⇒ wk+1; · · ·wj
Input : G = 〈N,Σ,P,S〉 et w = w1, · · · ,wn
Output : w ∈ L(G)P ← new Array [n + 1][n + 1]1
for i ← 1 to n do2
if X → wi ∈ P then3
P[i − 1][i ]← P[i − 1][i ] ∪ {X}4
for j ← 1 to n do5
for i ← j − 2 downto 0 do6
for k ← i + 1 to j − 1 do7
if X → A B ∈ G ∧ A ∈ P[i ][k] ∧ B ∈ P[k][j] then8
P[i ][j]← P[i ][j] ∪ {X}9
return S ∈ P[n + 1][n + 1]10
34
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN
1 2 3 4 5 6 7 80 Det
1 N
2 V
3 Det
4 N
5 Prep
6 Det
7 N
35
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
S → SN SV
S → SN V
SN → Det N
SN→ Det N
SN → X1 SNP
X1 → Det N
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN
1 2 3 4 5 6 7 80 Det SN,X1
1 N
2 V
3 Det
4 N
5 Prep
6 Det
7 N
A : 0 Le 1 B : 1 chat 2
35
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN
1 2 3 4 5 6 7 80 Det SN,X1
1 N
2 V
3 Det
4 N
5 Prep
6 Det
7 N
A : 1 chat 2 B : 2 mange 3
35
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN
1 2 3 4 5 6 7 80 Det SN,X1
1 N
2 V
3 Det
4 N
5 Prep
6 Det
7 N
A : 0 Le 1 B : 1 chat 2 mange 3
35
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
S → SN SV
S→ SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN
1 2 3 4 5 6 7 80 Det SN,X1 S
1 N
2 V
3 Det
4 N
5 Prep
6 Det
7 N
A : 0 Le 1 chat 2 B : 2 mange 3
35
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
S → SN SV
S → SN V
SN → Det N
SN → X1 SNP
X1 → Det N
SNP → Prep SN
SV → V SN
SV → X2 SNP
X2 → V SN
1 2 3 4 5 6 7 80 Det SN,X1 S S S
1 N
2 V SV ,X2 SV ,X2
3 Det SN,X1 SN
4 N
5 Prep SNP
6 Det SN,X1
7 N
35
Exemple et complexité
0 Le 1 chat 2 mange 3 la 4 souris 5 dans 6 le 7 jardin 8
1. S → SN SV
2. S → SN V
3. SN → Det N
4. SN → X1 SNP
5. X1 → Det N
6. SNP → Prep SN
7. SV → V SN
8. SV → X2 SNP
9. X2 → V SN
1 2 3 4 5 6 7 8
0Det SN,X1 S S S
(1, 5) (2) (1) (1)
1N
2V SV ,X2 SV ,X2
(7, 9) (7/8, 9)
3Det SN,X1 SN
(3, 5) (4)
4N
5Prep SNP
(6)
6Det SN,X1
(3, 5)
7N
Complexité temporelle O(n3)35
Conclusion
Programmation dynamique adaptée pour :
Des problèmes décomposables en sous-problèmes
Les sous-problèmes se chevauchent
Une solution au problème est une composition des solutionsaux sous-problèmes
Le principe consiste à :
Procéder de manière ascendante
Stocker les résultats intermédiaires
36