1. Programmation Dynamique
Mise en œuvre et application à des problèmes en TAL
Sébastien Combéfis
23 décembre 2009

2. 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

3. Algorithme naif pour le problème du change
Il faut rendre une certaine quantité d’argent M sous forme de
pièces, tout en rendant un minimum de pièces
Un algorithme naif utilisé par la plupart des caissiers
Input : M une quantité d’argent positive
Output : Liste de pièces à rendre pour former M, tel que le
nombre de pièces soit minimal
L ←1
while M > 0 do2
c ← La pièce de plus grande valeur tel que c ≤ M3
L ← L + c4
M ← M − c5
return L6
3

4. Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 40
25
20
10
5
⊲
4

5. Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 15
25
20
10
5
⊲
25
4

6. Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 5
25
20
10
5⊲
25 10
4

7. Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 0
25
20
10
5
25 10 5
4

8. Exemple d’exécution de l’algorithme
Rendre 40 cents avec des pièces de 25, 20, 10 et 5 cents
M 0
25
20
10
5
25 10 5
Ce n’est pas la solution optimale !
L’algorithme proposé n’est pas correct !
4

9. Algorithme brute-force
Pour être sûr d’avoir la solution optimale, on peut explorer
toutes 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

10. Algorithme brute-force
On choisit ensuite la solution qui qui coute le moins cher (ou
une 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

11. Programmation dynamique I
Résoudre un problème en s’attaquant à des sous-problèmes
similaires au problème initial et plus simples à résoudre
Éviter de calculer plusieurs fois la même chose en exploitant la
mé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

12. Programmation dynamique II
Contrairement à l’approche « Diviser pour Régner » , les
sous-problèmes peuvent se superposer
Méthode ascendante, on commence par résoudre les petits
sous-problèmes pour obtenir une solution au problème initial
Diviser pour régner Programmation dynamique
7

13. Retour sur le problème du change
Définition récursive du problème :
ChangeM = min



ChangeM−5 + 1
ChangeM−10 + 1
ChangeM−20 + 1
ChangeM−25 + 1
Pour trouver le nombre optimal de pièces sommant à M, on
essaie toutes les possibilités et on prend la meilleure
8

14. Algorithme récursif
Une version récursive de l’algorithme :
Input : M une quantité d’argent positive
Output : 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

15. Algorithme récursif
Une version récursive de l’algorithme :
min
c∈Coins
Change(M − c)
Input : M une quantité d’argent positive
Output : 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

16. Exemple et complexité
L’algorithme n’est pas du tout efficace, de nombreux
sous-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

17. Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
Input : M une quantité d’argent positive
Output : 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

18. Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
min
c∈Coins
tab[m − c]
Input : M une quantité d’argent positive
Output : 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

19. Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . +∞
m 40
c
12

20. Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . +∞
m 40
c 5
12

21. Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 3
m 40
c 10
12

22. Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 3
m 40
c 20
12

23. Exemple et complexité
tab
0 1 15 20
0 +∞ . . . 2 . . . 1
30 35 40
. . . 2 . . . 2 . . . 2
m 40
c 25
12

24. 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 de
celles de Changem pour m < M
12

25. 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
ChangeRec
ChangeDP
Version récursive en O(Md)
Version programmation dynamique en O(Md)
13

26. Obtenir les dénominations des pièces
Il suffit d’ajouter un tableau qui stocke une pièce :
Input : M une quantité d’argent positive
Output : 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

27. 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

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
16

29. Algorithme de Viterbi
Utilisé pour résoudre le problème du décodage sur un modèle
de Markov caché (HMM)
Problème du décodage
Soit un HMM M = (Q, Σ, π, a, b) et une séquence d’observations
O = o0, o1, · · · , oT−1 , le problème du décodage consiste à
trouver la séquence d’état q = q0, q1, · · · , qT−1 la plus probable
qui a généré la séquence d’observations O.
17

30. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(Florence) = 0.6
Q = (S, V , C)
π = (0.6, 0.3, 0.1)
ω = (0.4, 0.3, 0.4)
18

31. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

32. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

33. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

34. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

35. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

36. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

37. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

38. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

39. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

40. 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.5
P(combat) = 0.1
P(Florence) = 0.4
P(il) = 0.1
P(combat) = 0.8
P(Florence) = 0.1
P(il) = 0.3
P(combat) = 0.1
P(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

41. 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

42. 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) = max
j∈Q
δt−1(j) · aj,i · bi,ot
19

43. 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 O
for 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 max
j∈Q
ωj · δT−1(j)
9
20

44. Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
max
j∈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 O
for 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 max
j∈Q
ωj · δT−1(j)
9
20

45. 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 × × ×
1
2
∗
21

46. 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
2
∗
δ0(S) = πS · bS,il = 0.3
δ0(V ) = πV · bV ,il = 0.15
δ0(C) = πC · bC,il = 0.05
21

47. 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

48. 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

49. 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

50. 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

51. 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

52. 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

53. 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

54. 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

55. 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

56. 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 = y (substitution)
Distance d’édition
Soient deux séquences a et b et une fonction de cout
w : (Σ ∪ {−}) × (Σ ∪ {−}) → R
La distance d’édition dw (a, b) = minS(w(S) | a ⇒S b) avec S une
séquence d’opérations d’édition
23

57. Spellcheck basé sur la distance d’édition
MITSY
24

58. Spellcheck basé sur la distance d’édition
MITSY
EMITSY
(−, E)
24

59. Spellcheck basé sur la distance d’édition
MITSY
EMITSY
EDITSY
(−, E)
(M, D)
24

60. Spellcheck basé sur la distance d’édition
MITSY
EMITSY
EDITSY
EDITS
(−, E)
(M, D)
(Y , −)
24

61. Spellcheck basé sur la distance d’édition
MITSY
EMITSY
EDITSY
EDITS
(−, E)
(M, D)
(Y , −)
-MITSY
EDITS-
24

62. 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

63. 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 mot
s1 · · · 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] + 1
M[i − 1, j] + 1
M[i − 1, j − 1] + (1 − δsi tj )
26

64. 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

65. Algorithme en programmation dynamique
Une version de l’algorithme en programmation dynamique :
min



M[i][j − 1] + 1
M[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

66. Exemple et complexité
ε P E T I T
ε 0 1 2 3 4 5
G 1
E 2
N 3
T 4
I 5
L 6
ε P E T I T
ε ← ← ← ← ←
G ↑
E ↑
N ↑
T ↑
I ↑
L ↑
28

67. Exemple et complexité
ε P E T I T
ε 0 1 2 3 4 5
G 1 1
E 2
N 3
T 4
I 5
L 6
ε P E T I T
ε ← ← ← ← ←
G ↑ տ
E ↑
N ↑
T ↑
I ↑
L ↑
M[1][1] =



M[1][0] + 1
M[0][1] + 1
M[0][0] + (1 − δGP)
G → P =



(G → ε) + 1
(ε → P) + 1
(ε → ε) + 1
28

68. Exemple et complexité
ε P E T I T
ε 0 1 2 3 4 5
G 1 1 2 3 4 5
E 2 2 1 2
N 3
T 4
I 5
L 6
ε P E T I T
ε ← ← ← ← ←
G ↑ տ տ← տ← տ← տ←
E ↑ տ↑ տ ←
N ↑
T ↑
I ↑
L ↑
M[2][3] =



M[2][2] + 1
M[1][3] + 1
M[1][2] + (1 − δET )
GE → PET =



(GE → PE) + 1
(G → PET) + 1
(G → PE) + 1
28

69. Exemple et complexité
ε P E T I T
ε 0 1 2 3 4 5
G 1 1 2 3 4 5
E 2 2 1 2 3 4
N 3 3
T 4
I 5
L 6
ε P E T I T
ε ← ← ← ← ←
G ↑ տ տ← տ← տ← տ←
E ↑ տ↑ տ ← ← ←
N ↑ տ↑
T ↑
I ↑
L ↑
M[3][1] =



M[3][0] + 1
M[2][1] + 1
M[2][0] + (1 − δNP)
GEN → P =



(GEN → ε) + 1
(GE → P) + 1
(GE → ε) + 1
28

70. Exemple et complexité
ε P E T I T
ε 0 1 2 3 4 5
G 1 1 2 3 4 5
E 2 2 1 2 3 4
N 3 3 2 2 3 4
T 4 4 3 2 3 3
I 5 5 4 3 2
L 6
ε P E T I T
ε ← ← ← ← ←
G ↑ տ տ← տ← տ← տ←
E ↑ տ↑ տ ← ← ←
N ↑ տ↑ ↑ տ տ← տ←
T ↑ տ↑ ↑ տ տ← տ
I ↑ տ↑ ↑ ↑ տ
L ↑
M[5][4] =



M[5][3] + 1
M[4][4] + 1
M[4][3] + (1 − δII)
GENTI → PETI =



(GENTI → PET) + 1
(GENT → PETI + 1
(GENT → PET) + 0
28

71. Exemple et complexité
ε P E T I T
ε 0 1 2 3 4 5
G 1 1 2 3 4 5
E 2 2 1 2 3 4
N 3 3 2 2 3 4
T 4 4 3 2 3 3
I 5 5 4 3 2 3
L 6 6 5 4 3 3
ε P E T I T
ε ← ← ← ← ←
G ↑ տ տ← տ← տ← տ←
E ↑ տ↑ տ ← ← ←
N ↑ տ↑ ↑ տ տ← տ←
T ↑ տ↑ ↑ տ տ← տ
I ↑ տ↑ ↑ ↑ տ ←
L ↑ տ↑ ↑ ↑ ↑ տ
GENTIL
PE-TIT
Complexité temporelle O(nm)
28

72. 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

73. 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 sont
de deux formes :
S → AB
S → a
Calcule toutes les interprétations possibles de toutes les
sous-séquences de la séquence d’entrée
30

74. 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

75. 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

76. 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

77. 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

78. 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

79. 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

80. 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 de
la chaine)
1 2 3 · · ·
0
1
2
...
L’entrée (i, j) correspond à la
sous-chaine commençant en i
et se finissant en j
32

81. 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 toutes
les découpes de la sous-chaine : wi , · · · , wk , · · · , wj
33

82. Algorithme en programmation dynamique
Pour une grammaire G = N, Σ, P, S , tester si une chaine
w = 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

83. Algorithme en programmation dynamique
Pour une grammaire G = N, Σ, P, S , tester si une chaine
w = w1, · · · , wn appartient à L(G)
On cherche les décompositions de
wi+1, · · · , wj avec S → A B dans
la 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

84. 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 8
0 Det
1 N
2 V
3 Det
4 N
5 Prep
6 Det
7 N
35

85. 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 8
0 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

86. 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 8
0 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

87. 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 8
0 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

88. 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 8
0 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

89. 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 8
0 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

90. 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
0
Det SN, X1 S S S
(1, 5) (2) (1) (1)
1
N
2
V SV , X2 SV , X2
(7, 9) (7/8, 9)
3
Det SN, X1 SN
(3, 5) (4)
4
N
5
Prep SNP
(6)
6
Det SN, X1
(3, 5)
7
N
Complexité temporelle O(n3)
35

91. 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 solutions
aux sous-problèmes
Le principe consiste à :
Procéder de manière ascendante
Stocker les résultats intermédiaires
36