Programmation Dynamique : Mise en œuvre et application à des problèmes en TAL

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



M 15

2520105⊲

25

4



M 5

2520105⊲

25 10

4



M 0

2520105

25 10 5

4



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)


if M = 0 then1

return 02

best ← +∞3


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 :


tab ← new Array [M + 1]1

tab[0]← 02

for m← 1 to M do3

tab[m]← +∞4


if m ≥ c then6

if tab[m − c] + 1 < tab[m] then7

tab[m]← tab[m − c] + 18

return tab[M]9

11



minc∈Coins

tab[m− c]



tab[0]← 02

for m← 1 to M do3

tab[m]← +∞4


if m ≥ c then6


tab[m]← tab[m − c] + 18

return tab[M]9

11


tab

0 1 15 20

0 +∞ . . . 2 . . . 1

30 35 40

. . . 2 . . . 2 . . . +∞

m 40

c

12


tab

0 1 15 20

0 +∞ . . . 2 . . . 1

30 35 40

. . . 2 . . . 2 . . . +∞

m 40

c 5

12


tab

0 1 15 20

0 +∞ . . . 2 . . . 1

30 35 40

. . . 2 . . . 2 . . . 3

m 40

c 10

12


tab

0 1 15 20

0 +∞ . . . 2 . . . 1

30 35 40

. . . 2 . . . 2 . . . 3

m 40

c 20

12


tab

0 1 15 20

0 +∞ . . . 2 . . . 1

30 35 40

. . . 2 . . . 2 . . . 2

m 40

c 25

12


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 :



tab[0]← 02

denom ← new Array [M + 1]3

for m← 1 to M do4

tab[m]← +∞5


if m ≥ c then7


tab[m]← tab[m − c] + 19

denom[m] ← c10

return tab[M]11

14

Plan

1 Introduction






Algorithme CKY

15

Plan

1 Introduction






Algorithme CKY

16


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



Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)

O = 〈il , combat,Florence〉

q = ?

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?

P(S,V ,C ; il , combat,Florence)

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= πS

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= πS · bS,il

18


S

V C

0

0.7

0.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= πS · bS,il · aS,V

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= πS · bS,il · aS,V · bV ,combat

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= πS ·bS,il ·aS,V ·bV ,combat ·aV ,C

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= πS · bS,il · aS,V · bV ,combat ·aV ,C · bC ,Florence

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3,0.4)


q = ?


= πS · bS,il · aS,V · bV ,combat ·aV ,C · bC ,Florence · ωC

18


S

V C

0

0.70.10.2

0.1

0.4

0.1

0.2

0.3




Q = (S,V ,C)

π = (0.6, 0.3, 0.1)

ω = (0.4, 0.3, 0.4)


q = ?


= π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


δ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



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



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


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


Soit la séquence d’observations O = 〈il, combat,Florence〉


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




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




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




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




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




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




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




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




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






Algorithme CKY

22


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)


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


MITSY

EMITSY(−,E )

24


MITSY

EMITSY

EDITSY

(−,E )

(M,D)

24


MITSY

EMITSY

EDITSY

EDITS

(−,E )

(M,D)

(Y ,−)

24


MITSY

EMITSY

EDITSY

EDITS

(−,E )

(M,D)

(Y ,−)

-MITSY

EDITS-

24


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


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



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



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


ε 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


ε 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


ε 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


ε 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


ε 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


ε 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






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


S → SN SV

S → SN V

SN → Det N

SN → X1 SNP

X1 → Det N

SNP → Prep SN

SV → V SN

SV → X2 SNP


Det N V Det N

X1

31


S → SN SV

S → SN V

SN→ Det N

SN → X1 SNP

X1 → Det N

SNP → Prep SN

SV → V SN

SV → X2 SNP


Det N V Det N

SN SN

31


S → SN SV

S→ SN V

SN → Det N

SN → X1 SNP

X1 → Det N

SNP → Prep SN

SV → V SN

SV → X2 SNP


Det N V Det N

SN SN

S

31


S → SN SV

S → SN V

SN → Det N

SN → X1 SNP

X1 → Det N

SNP → Prep SN

SV→ V SN

SV → X2 SNP


Det N V Det N

SN SN

SV

31


S→ SN SV

S → SN V

SN → Det N

SN → X1 SNP

X1 → Det N

SNP → Prep SN

SV → V SN

SV → X2 SNP


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


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


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


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


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


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



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



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



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



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



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



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

Programmation Dynamique : Mise en œuvre et application à des problèmes en TAL

Documents

Transcript of Programmation Dynamique : Mise en œuvre et application à des problèmes en TAL