H.Todorov - Freehostia.com

Transcription

L ABORATOIRE D ’I NFORMATIQUE
DE
NANTES ATLANTIQUE
Analyse syntaxique des
grammaires catégorielles de
dépendances stochastiques
Hristian Todorov
encadré par Alexandre Dikovsky et Denis Béchet
Laboratoire d’Informatique de Nantes Atlantique
2, rue de la Houssinière
B.P. 92208
F-44322 NANTES CEDEX 3
R APPORT
DE
S TAGE
DE
M ASTER R ECHERCHE
Août 2007
LINA, Faculté des Sciences & Techniques de Nantes
B.P. 92208 — F-44322 NANTES CEDEX 3
Hristian Todorov (encadré par Alexandre Dikovsky et Denis Béchet)
Analyse syntaxique des grammaires catégorielles de dépendances stochastiques
c Août 2007 par Hristian Todorov
rapport.tex – Analyse syntaxique des grammaires catégorielles de dépendances stochastiques – 31/8/ 2007 – 8:48
Analyse syntaxique des grammaires catégorielles
de dépendances stochastiques
Hristian Todorov (encadré par Alexandre Dikovsky et Denis Béchet)
[email protected]
3
Remerciements
Je tiens à remercier mon encadrant Alexandre Dikovsky et aussi Denis Béchet pour leurs conseils pendant
ce stage et pour leur précieuse aide avec l’étiquetage syntaxique. Je remercie Darin Todorov pour son aide
dans l’énorme travail de ce sujet. Je remercie Jean Nicolet pour son travail sur l’étiquetage prosodique.
Je remercie l’équipe de TALN de nous avoir prêté des outils automatiques d’analyse morphosyntaxique
et toutes les personnes qui ont contribué à ce travail.
Chapitre 1
Introduction
Le premier objectif de ce stage de Master est de concevoir un algorithme linéaire pour l’analyse syntaxique des grammaires catégorielles de dépendances stochastiques. Des algorithmes pour analyse syntaxique ont déjà été développés et ne posent pas un problème nouveau. La plupart des méthodes proposées s’applique aux grammaires formelles de Chomsky, i.e. les grammaires des structures des phrases.
Nous nous plaçons dans le cadre des grammaires catégorielles de dépendances qui sont assez expressives pour traiter la syntaxe des langues naturelles, qui ont une théorie mathématique élégante et en
même temps ont une complexité d’analyse polynomiale pratique. Pour les termes de dépendances nous
mettons en œuvre l’analyse syntaxique de surface et également comme pour chaque autre système d’étiquetage, une liste des types atomiques de dépendances utilisées a été développée pendant ce travail.
Le travail effectué durant ce stage décrit la deuxième partie d’un système expérimental pour analyse
syntaxique automatique basé sur l’apprentissage supervisé sur des informations prosodiques et morphologiques. A ce stade nous ne connaissons pas d’article ou de système déjà en exploitation qui utilise des
informations prosodiques et morphologiques pour effectuer une analyse syntaxique correcte.
Le deuxième objectif de ce stage est d’affecter les types syntaxiques aux classes des formes (et non aux
mots). Ceci est réalisé à l’aide d’une base de données développée durant ce stage.
Au chapitre 2 nous commençons avec un résumé des méthodes et techniques existantes dans ce domaine.
Puisque nous allons développer un algorithme pour la construction d’un arbre syntaxique, la première
partie du chapitre 2 va présenter les deux principales structures utilisées pour la représentation de la syntaxe, en détaillant leurs propriétés formelles. Après on va se concentrer sur les techniques courantes pour
la dérivation d’un arbre syntaxique et résumer les deux principaux algorithmes CYK et Earley.
Au chapitre 3 nous présentons les grammaires catégorielles de dépendances(CDG) sur lesquelles notre
algorithme AlgoLR est basé. Une grammaire très expressive et en même temps analysée en temps polynomial.
Le chapitre 4 représente le cœur de ce travail. Il présente un algorithme qui, étant donné une séquence
d’interprétations grammaticales en termes de CDG, reconnaît si la phrase est correcte et puis fournit la
structure syntaxique. Tout cela en temps linéaire.
Enfin nous consacrons le chapitre 5 à la présentation de la base de données et de la structure du système.
5
6
Finalement dans la conclusion nous proposons quelques perspectives pour continuer et améliorer le système.
Chapitre 2
Types d’analyseurs
2.1 Arbres de dépendances et arbres de constituants.
D’après le linguiste Igor Melchuk [MP87] il y a deux manières diamétralement opposées de représenter des phrases normales au niveau syntactique : arbres de constituants (AC) et arbres de dépendances
(AD). Évidemment, c’est possible de créer n’importe quelle combinaison des deux méthodes (et en fait
quelques ont été déjà suggérées), avec des compromis trouvés à différentes places ; mais il est important
de souligner qu’il n’y a aucune troisième possibilité essentiellement différente. Ce qui suit est une comparaison entre les deux méthodes, expliquant des arbres de dépendances en termes de leurs différences à
partir des arbres de constituants.
Un AC montre quels éléments - formes du mot ou des expressions - du langage naturel donné " vont
ensemble ", ou combinent avec quels d’autres éléments pour former des unités complètes d’un niveau
plus haut. Cette approche repose sur le constituant et donc s’appelle " la méthode de constituants ".
Un arbre de dépendances est tout à fait différent à cet égard : il montre plutôt quels éléments sont reliés auxquels d’autres éléments, et de quelle manière. Cette approche, contrairement à l’approche de
constituants, repose sur les relations entre les unités syntactiques finales, c.-à-d. les formes des mots (les
feuilles d l’arbre) et laisse la formation des unités syntactiques d’un niveau plus haut indefinies.
Dans un AC, l’appartenance à classe syntactique des unités syntactiques est indiquée comme partie intégrale de la représentation syntactique, alors que les relations parmi les unités ne sont pas énoncées
explicitement. Dans un AD, au contraire, les types de relations syntactiques sont facilement indiqués
mais l’appartenance à classe syntactique des unités (élémentaires aussi bien que d’un niveau plus haut)
n’est pas montrée immédiatement dans la représentation syntactique : pour une unité élémentaire, c.-à-d.
un mot, toute cette information fait partie de l’entrée dans la dictionnaire pour le lexème correspondant,
de sorte qu’elle reste dans les coulisses ; pour une unité d’un niveau plus haut, une telle information
n’est pas nécessaire simplement dans la plupart des cas. (Dans les cas exceptionnels, d’après Melchuk,
où les informations syntactiques sur une unité d’un niveau plus haut peuvent être nécessaires, elles sont
facilement dérivées sur la base de l’information assignée aux composants de l’unité.)
Un corollaire de ce qui précède est qu’un arbre de dépendances contient uniquement des noeuds termineaux , alors que la plupart des noeuds dans un AC sont non-termineaux.
7
8
Dans un AC, les nœuds terminaux doivent être linéairement ordonnés. L’ordre n’est pas nécessairement
celui des mots réels dans la phrase représentée mais un certain ordre linéaire est inévitable. Dans un AD,
il n’y a aucun ordre linéaire des nœuds. L’ordre linéaire des symboles n’est pas permis de diffuser de
l’information dans les représentations syntactiques (et sémantiques) ; tout doit être exprimé explicitement
au moyen de symboles. Cependant, cette vue de Melchuk contredit la plupart des théories linguistiques
modernes.
Un AC n’indique pas les relations syntactiques entre les unités syntactiques, au moins pas d’une façon
explicite. Un AD cependant, indique en détail le type de n’importe quelle relation entre deux éléments
syntaxiquement reliés. Ces relations sont binaires et dirigées. L’étiquetage de toutes les branches dans un
arbre de dépendances constitue un trait très important.
Un exemple schématique suit. La phrase
"A girl at whom no one made passes no longer resents wearing glasses"
peut être assigné les structures de constituants (F IG . 2.1 ) et de dépendances (F IG . 2.2 ) suivantes
montrées ci-dessous.
F IG . 2.1 – PS-arbre
9
F IG . 2.2 – D-arbre
Puisqu’il n’y a aucun ordre linéaire des nœuds dans les arbres de dépendances, les variantes a et b, ansi
que toutes les autres variantes données par des permutations linéaires des noeuds, sont complètement
équivalentes.
2.2 Le processus d’analyse syntaxique
Le processus reconnaissant une séquence de mots et de lui assignant une certaine structure syntactique
s’appelle analyse syntaxique. Les arbres syntaxiques sont directement utiles dans les applications comme
la vérification de la grammaire pour les systèmes de traitement de texte. En outre, l’analyse est une étape
de représentation intermédiaire dans les applications comme la traduction automatique, les systèmes de
question - réponse , et l’extraction d’information.
L’analyse syntaxique peut avoir deux objectifs différents :
- reconnaître une séquence de mots. Par exemple : Est-ce que telle phrase est correcte ou non ?
- fournir une analyse pour une séquence de mots donnée, i.e. toutes les dérivations possibles qui construisent
la structure syntaxique.
2.3 Analyse de haut en bas et ascendant
Fondamentalement il y a deux stratégies principales de recherche sous-tendant la plupart des analyseurs
syntaxiques : recherche de haut en bas ou but-dirigée et recherche ascendante ou dirigée par les données.
Le but d’un analyseur syntaxique est d’atteindre une forme sentential finale en utilisant les règles de
production de la grammaire et l’annotation des mots dans le lexique. La grammaire et le lexique ainsi
que les résultats intermédiaires de l’algorithme d’analyse syntaxique constituent l’espace de recherche
de l’analyseur.
10
Analyse de haut en bas.
Un analyseur syntaxique de haut en bas recherche un arbre syntaxique en commençant la construction
par la racine S puis en continuant vers les feuilles en bas . L’algorithme commence par assigner le symbole de début S à l’entrée. La prochaine étape est de trouver les sommets de tous les arbres qui peuvent
commencer par S et ainsi de construire chaque arbre possible jusqu’aux feuilles .
Analyse ascendante.
L’algorithme d’analyse syntaxique le plus ancien est de type ascendant. Il a été suggéré pour la première
fois par Yngve (1955). Dans l’analyse ascendante, l’analyseur commence par les mots de l’entrée, et
essaie de construire des arbres par l’application des règles de la grammaire une par une. L’analyse est
réussie si l’analyseur réussit à construire un arbre enraciné par le symbole de début S qui couvre tous les
mots de l’entrée.
2.4 Comparaison entre les deux méthodes
Chacune de ces deux méthodes a ses avantages et ses inconvénients. La stratégie de haut en bas ne gaspille jamais de temps en explorant des arbres qui ne peuvent pas avoir un S comme un racine, puisque
elle ne produit que ces arbres. Ceci signifie qu’elle n’explore jamais des sous-arbres qui ne peuvent pas
se trouver dans un arbre avec racine S. Dans la stratégie ascendante, en revanche, des arbres qui n’ont
aucun espoir de mener à un S sont créés.
L’approche de haut en bas a ses propres inefficacités. Tandis qu’elle ne perd pas du temps avec les arbres
qui ne mènent pas à un S, l’approche dépense beaucoup d’efforts sur les arbres de S qui ne se conforment
pas à l’entrée. Cette faiblesse des analyseurs de haut en bas résulte du fait qu’ils peuvent produire des
arbres avant d’examiner l’entrée. Les analyseurs ascendants, par contre, ne suggèrent jamais des arbres
qui ne sont pas localement reliés à l’entrée réelle.
Il y a de nombreuses manières de combiner les meilleurs traits de l’analyse de haut en bas et de l’analyse
ascendante dans un algorithme simple ainsi que des techniques d’optimisation. Un exemple est la stratégie de recherche en profondeur de gauche à droite/depth-left-first search/ avec un filtrage ascendant.
Pour plus de détails et d’autres optimisations le lecteur est dirigé vers [JM00] et [SN97].
2.5 Problèmes avec les algorithmes d’analyse syntaxique
Malgré l’optimisation mentionnée, il reste encore trois problèmes : récursion, ambiguïté et reparsing inefficace des sous-arbres.
Récursion
Ce problème se manifeste quand des grammaires récursives sont utilisées. Les règles suivantes sont
toutes gauche-récursives : NP 7→ NP PP ; VP 7→ VP PP ; S 7→ SS.
Ambiguïté
L’ambiguïté (syntaxique) structurale se produit quand la grammaire assigne plus qu’une analyse possible
11
à une phrase. Par exemple la phrase " Le soldat brave la garde " a deux analyses possibles qui possèdent
différentes significations :
F IG . 2.3 – ambiguïté syntaxique 1
F IG . 2.4 – ambiguïté syntaxique 2
Dans le premier cas (F IG . 2.3 ) le verbe principal est ’garder’ qui est en relation prédicative avec ’combattant’. Alors que dans la deuxième cas (F IG . 2.4 ) le verbe principal est ’braver’ et ’garde’ est le
complément d’objet direct.
Des algorithmes de désambiguïsation existent mais généralement ils exigent des informations supplémentaires statistiques ou sémantiques. Les analyseurs qui n’incorporent pas de désambiguïsation doivent
simplement renvoyer tous les arbres syntaxiques possibles pour une entrée donnée.
Un algorithme de ce type sera passé en revue en détail en chapitre 3. Le même algorithme a été employé
pour générer les images ci-dessus. Le problème de la désambiguïsation dans notre système est résolu à
l’aide d’informations morpho-syntactiques et prosodiques. Pour plus de détails sur ceci voir [DT07].
Analyse des sous-arbres répétés
L’analyseur construit souvent des arbres valides pour des parties de l’entrée et les rejette pendant la
marche en arrière, et puis découvre qu’il doit les reconstruire encore.
Ce problème est résolu avec la programmation dynamique. Ainsi les sous-arbres ne sont découverts
qu’une fois, et après réutilisés pendant l’analyse syntaxique. Un algorithme classique qui emploie la programmation dynamique est l’algorithme d’Earley qui porte le nom de son inventeur.
Ce qui suit est une description des deux algorithmes classiques pour l’analyse syntactique. L’algorithme
CYK et Earley. Il est important de mentionner que les deux algorithmes résolvent tous les problèmes
12
mentionnés ci-dessus avec les algorithmes d’analyse syntaxique.
2.6 L’algorithme CYK(Cocke-Younger-Kasami)
Cet algorithme a été proposé par Cocke, Younger et Kasami en 1965. Il réalise une analyse syntaxique
de type tabulaire ascendant : celle-ci part de la séquence de mots à analyser et tente d’atteindre l’axiome
en utilisant les règles de production de droite à gauche. L’algorithme CYK a deux avantages :
– sa complexité dans le pire des cas est optimale ( O(n3 )) ;
– et il est sample à implémenter ;
Il présente cependant deux inconvénients :
– nécessite la transformation de la CFG sous une forme particulière : forme normale de Chomsky(CNF) ;
– reste O(n3 ) sur des grammaires de complexité inférieure (e.g. régulières) ;
Le remplissage de la table s’effectue de bas en haut et de gauche à droite (c.-à-d. dans le sens de la phrase)
Il faut noter qu’un arbre de dérivation pour une phrase et une grammaire en CNF est essentiellement
un arbre binaire : seule l’utilisation des productions du type X 7→ a crée des nœuds avec un seul fils.
Il convient également de remarquer que pour une grammaire G en CNF, il n’existe pas de non-terminal
pouvant se dériver en ε (le mot vide).
Considérons la grammaire en CNF suivante :
S 7→ AB|BB
A 7→ CC|AB|a
B 7→ BB|CA|b
C 7→ BA|AA|b
Si cette grammaire engendre un mot w alors cela signifie qu’il existe un découpage du mot w en deux
mots w1 et w2 tous les deux différents de ε et, selon les règles de production pour S, tel que :
– soit A 7→∗G w1 et B 7→∗G w2,
– soit B 7→∗G w1 et B 7→∗G w2.
Il faut noter que si w est de longueur n alors il existe n − 1 découpages possibles.
Considérons un mot a1 a2 ...an . L’algorithme fonctionnant de manière ascendante, il va tenter à partir de
fragments de ce mot de reconstruire un arbre de dérivation en utilisant le procédé suivant : si on sait que
Y 7→G ai ...aj et que Z 7→G aj+1 ...ak et que X 7→ Y Z est une règle de la grammaire alors on peut en
déduire que X 7→G ai ...ak . L’algorithme applique ce principe itérativement pour toutes les longueurs l
possibles des sous-mots du mot à analyser a1 a2 ...an , c’est-à-dire pour l allant de 1 à n.
L’entité de base de l’algorithme est la cellule. Une cellule est identifiée par un couple d’entiers (l, i) tel
que l, i ≤ n. Le contenu d’une cellule est un ensemble de non-terminaux. La cellule (l, i) contient le
non-terminal X si et seulement si il existe une dérivation partant de X et générant le fragment du mot
a1 a2 ...an commençant à l’indice i et de longueur l, c’est-à-dire si X 7→G ai ...ai+l−1 . L’algorithme va
donc remplir ces cellules selon les l, puis les j croissant en utilisant les règles de la grammaire et les
cellules rempliées aux itérations précédentes. Ainsi le mot a1 a2 ...an est engendré par la grammaire si et
13
seulement si l’axiome de la grammaire appartient à la cellule (n, 1).
Pour la première itération de l’algorithme (l = 1), les fragments sont les terminaux et donc les seules
règles de production utilisables sont les règles X 7→ a. Ainsi, une cellule (1, i) contient le non-terminal
X si ai est le terminal a et X 7→ a est une règle de production de la grammaire. Pour une itération 1 < l,
la cellule (l, i) contient le non-terminal X si et seulement s’il existe un découpage du mot ai ...ai+l−1 en
ai ...ai+m−1 et ai+m ...ai+l−1 pour m compris entre 1 et l − 1 tel que :
– Y 7→G ai ...ai+m−1 ,
– Z 7→G ai+m ...ai+l−1 et
– X 7→ Y Z est une règle de production de la grammaire.
Selon l’algorithme, cela signifie que la cellule (l, i) contient le non-terminal X si et seulement s’il existe
un entier m compris entre 1 et l − 1 tel que :
– Y appartient à la cellule (m, i),
– Z appartient à la cellule (l − m, i + m) et
– X 7→ Y Z est une règle de production de la grammaire.
L’algorithme est donc le suivant :
analyseCYK(a1 ...an )
pour i allant de 1 à n faire
Si (X 7→ ai appartient aux règles de la grammaire)
Alors mettre X dans la cellule (1, i) ;
fin si ;
fin pour ;
pour l allant de 2 à n faire
pour i allant de 1 à n − l + 1 faire
pour m allant de 1 à l − 1 faire
Si (X 7→ Y Z appartient aux règles de la grammaire
avec Y dans la cellule (m, i) et
Z dans la cellule (l − m, i + m))
Alors ajouter X à la cellule (l, i) ;
fin si ;
fin pour ;
fin pour ;
fin pour ;
retourner (la cellule (n, 1) contient S ?) ;
fin analyseCYK ;
L’algorithme précédent est seulement un reconnaisseur comme il ne garde pas trace des arbres d’analyse. Pour avoir un analyseur, il est nécessaire de garder trace des arbres d’analyse pendant l’analyse
elle-même. Par exemple, il suffit de rajouter Y et Z aux interprétations de X dans la cellule (l, i).
Complexité
Le calcul des interpretations présentes dans la case (l, i) nécessite (l − 1) explorations de paires de cellules (1 ≤ m ≤ l − 1), le nombre total d’explorations est donc :
14
Pn
l=2
Pn−l+1
i=1
(l − 1) =
Pn
l=1 (n
− l + 1)(l − 1) = O(n3 )
Dans le pire des cas chaque cellule contient tous les non-terminaux possibles, soit |C| éléments et donc
l’exploration du produit croisé des contenus de deux cases est dans le pire des cas en |C|2 . D’ou la complexité : O(n3 ) et O(|C|2 ).
On voit ici l’inconvénient de la mise sous forme normale de Chomsky qui augmente la taille de C (symboles non-termineaux) . Pour un algorithme CYK modifié s’affranchissant de la transformation sous
forme normal de Chomsky (C plus petit) voire [JP00].
Une fois la table remplie (en O(n3 )) un arbre d’analyse peut s’extraire en O(n).
2.7 L’algorithme d’Earley
L’algorithme d’Earley (Earley, 1970) emploie une approche de programmation dynamique pour mettre
en application efficacement une recherche de haut en bas parallèle. Comme avec beaucoup de solutions
de programmation dynamique, cet algorithme ramène apparemment un problème de temps exponentiel
à un temps polynômial en éliminant les resolutions répetées de sous-problèmes. Dans ce cas, l’approche
de la programmation dynamique mène à une complexité dans les pires des cas d’O(N 3 ), où N est le
nombre de mots dans l’entrée.
Le noyau de l’algorithme d’Earley est un simple passage de gauche à droite qui remplit une table appelé
un chart avec N + 1 places. Pour chaque position de mot dans la phrase, la table contient une liste d’états
représentant le partiel analyse des arbres qui ont été produits. Vers la fin de la phrase, la table code de
manière compacte toutes les analyses possibles de l’entrée. Chaque sous-arbre possible est représenté
seulement une fois et peut être partagé par tous les autres états.
Les différents états contenus dans chaque case de la table contiennent trois genres d’information : un
sous-arbre correspondant à une simple règle de grammaire, une information sur le progrès accompli en
achevant ce sous-arbre et la position du sous-arbre par rapport à l’entrée. Graphiquement un point est
employé dans le côté droit de la règle de la grammaire d’un état pour indiquer le progrès accompli en
reconnaissant la règle. La structure résultante s’appelle une règle pointillée. La position d’un état par
rapport à l’entrée sera représentée par deux numéros indiquant où l’état commence et où son point se
trouve. Considérons les exemples suivants :
S 7→ • VP, [0, 0]
NP 7→ Det • Nominal, [1, 2]
VP 7→ V NP •, [0, 3]
La première règle indique que rien n’a été reconnu. Dans la deuxième règle seulement un determinant est
identifié et les index [1, 2] signifient que le groupe nominal commence à partir du premier mot (inclus)
et finit devant le deuxième mot. La troisième règle indique qu’on a identifié une expression entière de
verbe qui contient trois mots.
15
L’opération fondamentale d’un analyseur d’Earley est de parcourir les N + 1 places d’états dans la table
de gauche à droite, traitant les états dans chaque place dans l’ordre. À chaque étape, un des trois opérateurs (Predictor, Scanner, Completer) est appliqué à chaque état selon la situation. À chaque étape, ceci
a comme conséquence l’ajout de nouveaux états dans la place courante ou la prochaine place de la table.
L’algorithme marche toujours en avant parcourant la table et faisant des ajout. Des états ne sont jamais
enlevés et l’algorithme ne fait jamais de retour en arrière jusqu’à un mot précédent. La présence d’un
état S 7→ α•, [0, N ] de la liste d’états dans la dernière place de la table indique que l’analyse a réussi.
Chacun des trois opérateurs prend un simple état comme entrée et dérive de nouveaux états de lui. Ces
nouveaux états sont alors ajoutés dans la table s’ils n’y sont pas déjà . Le PREDICTOR et le COMPLETER ajoutent des états dans la place courante de la table, alors que le SCANNER ajoute un état à la
prochaine case de la table.
Predictor
Le PREDICTOR est appliqué à n’importe quelle règle qui a un symbole non-terminal sur la droite et
qui n’est pas une catégorie de partie du discours. En conséquence, de nouveaux états sont créés et placés
dans la même case de la table que l’état courant. Par rapport à l’entrée ils commencent et finissent où
l’état courant finit. Par exemple, l’application du PREDICTOR à l’état S 7→ •VP,[0, 0] mène à l’ajout des
règles suivantes VP 7→ •Verb,[0, 0] et VP 7→ •Verb NP,[0, 0] dans la première case.
Scanner
Quand un état a une catégorie de partie du discours à la droite du point, le SCANNER est appelé pour
examiner l’entrée. Ceci crée un nouvel état avec le point avancé après la catégorie du discours rencontrée dans l’entrée. Par exemple, quand l’état VP7→ • Verb NP, [0, 0] est traité, le SCANNER consulte le
mot courant dans l’entrée. Si une entrée appropriée dans le lexique existe ceci a comme conséquence la
création du nouvel état VP 7→ Verb •NP, [0, 1]. Le nouvel état n’est pas alors ajouté à la case courante
mais à la prochaine case de la table.
Completer
Le COMPLETER est appliqué à un état quand son point a atteint la fin de la règle. Intuitivement, la présence d’un tel état représente le fait que l’analyseur a avec succès découvert une catégorie grammaticale
d’un niveau plus haut. De nouveaux états sont alors créés en copiant l’état plus ancien, avançant le point
après la catégorie prévue et plaçant le nouvel état dans la case courante. Par exemple quand l’état NP
7→ Det Nominal •, [1, 3] est traité, le COMPLETER recherche des états finissant à 1 et attendant un NP.
Pour l’exemple courant, il trouvera l’état VP 7→ Verb • NP, [0, 1] créé par le SCANNER. Le résultat est
l’ajout d’un nouvel état complet VP 7→ Verb NP •, [0, 3].
Ce qui suit est un pseudo-code de l’algorithme d’Earley.
function EARLEY-PARSE(words, grammar) returns chart
Enqueue(( y 7→ •S, [0, 0]), chart[0])
for i from 0 to length(words) do
for each state in chart[i] do
If Incomplete ?(state) and
16
next-cat(state) is not a part of speech
then
Predictor(state)
elseif Incomplete ?(state) and
next-cat(state) is a part of speech
then
Scanner(state)
else
Completer(state)
end
end
return(chart)
procedure Predictor((A 7→ α • Bβ, [i, j]))
for each (B 7→ y) in Grammar-rules-for(B, grammar) do
Enqueue((B 7→ •y, [j, j]), chart[ j ])
end
end
procedure Scanner((A 7→ α • Bβ, [i, j]))
if B ⊂ Parts-of-speech(word[j]) then
Enqueue((B 7→ word[j]•, [j, j + 1]), chart[j + 1])
end
procedure Completer((B 7→ y • [j, k]))
for each (A 7→ α • Bβ, [i, j]) in chart[ j ] do
Enqueue((A 7→ αB • β, [i, k]), chart[k])
end
end
procedure Enqueue(state, chart-entry)
if state is not already in chart-entry then
Push(state, chart-entry)
end
Recherche de l’arbre syntaxique dans la table.
La version de l’algorithme d’Earley décrite est réellement un système de reconnaissance pas un analyseur syntaxique. Après le traitement, les phrases correctes vont laisser l’état S 7→ •, [0, N ] dans la table.
Malheureusement cette forme sentential manque de la structure arborescente du S. Pour transformer
cet algorithme en analyseur syntaxique, nous devons pouvoir extraire les dérivations individuelles de la
table. Pour faire ça, la représentation de chaque état peut être augmentée avec un champ supplémentaire
pour stocker des informations sur les états complets qui ont produit ses constituants.
Cette information peut être ramassée en faisant un simple changement au COMPLETER. Le seul changement nécessaire de faire est ajouter à COMPLETER un pointeur vers l’état plus ancien sur la liste des
17
états précédents dans le nouvel état. La recherche d’un arbre syntaxique dans la table est alors simplement une récupération récursive commençant par l’état représentant un S complet dans la case finale de
la table.
2.8 Algorithmes d’analyse tabulaire
L’algorithme d’Earley a mené à une nouvelle famille d’algorithmes d’analyse appelés les analyseurs tabulaires. Ils utilisent tous la notation de règle pointillée des états et partagent l’idée de garder une table
d’une manière ou d’une autre. Les différents analyseurs tabulaires sont plus ou moins semblables à celui
d’Earley et c’est pour ça qu’ils sont également connus comme des algorithmes de type Earley. Les trois
opérateurs (SCANNERS, PREDICTOR, COMPLETER) sont également présents ici et jouent toujours le
même rôle mais ils s’appellent : respectivement la règle d’initialisation, l’extenseur et la règle fondamentale .
Il y a des analyseurs tabulaires qui utilisent différentes stratégies de recherche comme décrit plus tôt - des
analyseurs de haut en bas et ascendants. Ces analyseurs ne se diffèrent que dans leur schéma de contrôle.
Ici nous montrerons seulement les étapes nécessaires pour mettre en œuvre ces stratégies. Pour l’analyse
ascendante suivre cette procédure :
1. Créer une table vide.
2. Appliquer la règle d’initialisation à chaque mot.
3. Jusqu’à il n’y a plus d’états possibles
3.1 Appliquer la règle extenseur partout où c’est possible.
3.2 Appliquer la règle fondamentale partout où c’est possible.
4. Renvoyer toutes les analyses correctes selon la table.
Pour l’analyse de haut en bas :
1. Créer une table vide.
2. Entrer l’état initial S’ 7→ S dans le table .
3. Jusqu’à il n’y a plus d’états possibles
3.1 Appliquer la règle extenseur partout où c’est possible.
3.2 Appliquer la règle d’initialisation partout où c’est possible.
3.3 Appliquer la règle fondamentale partout où c’est possible.
4. Renvoyer toutes les analyses correctes selon la table
2.9 Optimisations et autres algorithmes
En général les optimisations qu’on peut appliquer sur ces algorithmes reduisent le nombre d’états pendant l’analyse et en conséquence le nombre de pas est reduit. Les techniques de filtrages sont de 3 types :
- statique : certaines règles de réécriture sont simplement enlevées ;
18
- dynamique : la validité de certains états dépend de la présence d’autres états , de cette manière l’information contextuelle est prise en compte ;
- contraction de pas : une séquence de pas de dérivation est remplacée par un seul pas de dérivation .
2.9.1 L’algorithme de Graham, Harrison, et Ruzzo
L’algorithme de Graham, Harrison, et Ruzzo(1980) est une version améliorée d’Earley qui utilise la
contraction de pas comme technique de filtrage. Les règles utilisées par cet algorithme(Scanner, Completer1, Completer2, Predictor) sont montrées au-dessous .
RInit. = {⊢ [S 7→ β • γ, 0, 0] | β ⇒∗ ε},
RScan = {[A 7→ α • aβγ, i, j], [a, j, j + 1] ⊢ [A 7→ αaβ • γ, i, j + 1] | β ⇒∗ ε},
RC1 = {[A 7→ α • Bβγ, i, j], [B 7→ δ•, j, k] ⊢ [A 7→ αBβ • γ, i, k] | i < j < k et β ⇒∗ ε},
RC2 = {[A 7→ α • Bβγ, i, i], [C 7→ δ•, i, j] ⊢ [A 7→ αBβ • γ, i, j] | i < j et B ⇒∗ C et β ⇒∗ ε},
RP red = {[A 7→ α • Bβ, i, j] ⊢ [C 7→ α′ • β ′ , j, j] | B ⇒∗ Cγ et α′ ⇒∗ ε}
2.9.2 L’algorithme de de Vreught et Honing
L’algorithme de de Vreught et Honing(1989) est aussi basé sur l’algorithme d’Earley mais il utilise une
règle avec deux points. Par exemples [A 7→ α • β • γ, i, j] veut dire que β 7→∗ ai+1 ... aj (est déjà
reconnu) alors que α et γ restent d’être reconnus. Les règles sont montrées au-dessous.
RInit = {[a, j − 1, j] ⊢ [A 7→ α • a • γ, j − 1, j]},
Rε = {⊢ [B 7→ ••, j, j]},
RInclude = {[B 7→ •β•, i, j] ⊢ [A 7→ α • B • γ, i, j]},
RConcat = {[A 7→ α • β1 • β2 γ, i, j], [A 7→ αβ1 • β2 • γ, j, k] ⊢ [A 7→ α • β1 β2 • γ, i, k]}
2.9.3 L’algorithme de Rytter
Un autre algorithme basé sur CYK et qui utilise le filtrage dynamique est l’algorithme de Rytter(1985).
Les états de Rytter ont la forme suivante [A, h, k; B, i, j]. Cet état est reconnu si A 7→∗ ah+1 ... ai Baj+1 ... ak ,
ça veut dire que la partie B 7→∗ ai+1 ... aj manque encore. Une autre manière d’interpréter un état de
Rytter est comme un état conditionnel : si [B, i, j] est valable alors [A, h, k] est aussi valable. Les règles
de Rytter sont montrées au-dessous. P étant l’ensemble de règles de production.
R0 = {[a, i − 1, i] ⊢ [A, i − 1, i] | A 7→ a ∈ P },
19
R1a = {[B, i, j] ⊢ [A, i, k; C, j, k] | A 7→ BC ∈ P },
R1b = {[C, j, k] ⊢ [A, i, k; B, i, j] | A 7→ BC ∈ P },
R2 = {[A, h, m; B, i, l], [B, i, l; C, j, k] ⊢ [A, h, m; C, j, k]},
R3 = {[A, h, k; B, i, j], [B, i, j] ⊢ [A, h, k]}
Pour d’autres informations sur les techniques de filtrage et les algorithmes, voir [SN97].
Jusqu’ici nous avons montré les modèles et les algorithmes classiques utilisés pour l’analyse syntaxique
basés sur les classes des mots comme partie du discours. Après nous allons résumer d’autres formalismes
existants qui essayent de modeliser l’analyse syntaxique de surface.
2.10 Grammaires de dépendances et de constituants
Les algorithmes jusqu’ici étaient présentés par rapport aux grammaires de constituants. Mais absolument
tous peuvent être facilement adaptés aux grammaires de dépendances, comme cela sera le cas avec l’algorithme présenté dans le chapitre suivant.
Les grammaires de constituants peuvent être vues comme des systèmes décrivant la manière dont les
mots se combinent pour former des unîtés plus importantes. Les feuilles de ces arbres s’appellent les
nœuds lexicaux. Les nœuds non terminaux sont connus sous le nom de nœud syntagmatique. Les feuilles
se combinent pour former des éléments de plus haut niveau. La même procédure de combinaison est
appliquée jusqu’à ce que le plus haut nœud de la phrase S soit atteint.
Cependant le problème des structures de constituants est qu’ils ne peuvent pas représenter des relations
discontinues et dans l’analyse syntaxique de surface quelques relations sont discontinues.
Par ailleurs, dans les grammaires de dépendance les constituants et les règles de productions ne jouent
aucun rôle fondamental. Au lieu de cela, la structure syntaxique d’une phrase est décrite purement en
termes de mots et de relations sémantiques ou syntactiques binaires entre ces mots (appelés les dépendances lexicologiques). Les grammaires de dépendance tirent souvent fortement du travail de Tesnière
(1959), et le nom ’dépendance’ a été probablement utilisé pour la première fois par David Hays. Mais
cette notion lexicologique de dépendance de grammaire est en fait plus ancienne que les grammaires
de constituants qui sont relativement récentes. Les grammaires de dépendances ont leurs racines dans le
Grec antique et les traditions linguistiques indiennes.
Chapitre 3
Grammaire Catégorielle de Dépendances
(CDG)
Ce chapitre va présenter les principes généraux sous-jacent aux grammaires catégorielles de dépendances : une classe de grammaire récemment proposée. Ils traitent les dépendances discontinues (les
particules négatives , les pronoms comparatifs, etc.) qui posent un défi pour la plupart des grammaires
de dépendances et pourtant resre analysables en temps polynomial.
3.1 Types synataxiques ( catégories )
Supposons qu’il faille définir le type syntaxique du mot " théorie ". Alors il y a deux points de vue :
"theory" en tant que gouverneur (début des flèches) et en tant que subordonné (fins des flèches). Voir les
exemples au-dessous(F IG . 3.1 et F IG . 3.2 ).
F IG . 3.1 – les dépendances entrant dans « théorie »
20
21
F IG . 3.2 – les dépendances sortant de « théorie »
De cette manière, nous devons naturellement tenir compte de la priorité des débuts des flèches par rapport au mot. Ceci peut être fait en utilisant les deux opérateurs ’\’ et ’/’. Un type primitif D correspond à
la dépendance entrante D. Dans les types complexes comme D\A , D correspond au début de la dépendance D. Les catégories du type X/Y et X\Y signifient respectivement que X exige Y sur sa droite et que
Y exige X sur sa gauche . Finalement nous devons trouver des combinaisons mutuellement compatibles
des flèches sortantes et d’une flèche entrante compatible avec les traits du mot " théorie ". Chaque une
des telles combinaisons décrit un type de dépendance.
Chaque combinaison compatible de plusieurs arcs sortants et d’un arc entrant décrit un type de dépendance :
F IG . 3.3 – un type de dépendance du mot «theory»
Dans l’exemple au-dessus(F IG . 3.3) , le type [modif∗ \det\dir-obj/attr-rel] assigné au mot "théorie" exige
zéro, un ou plusieurs subordonnants gauches par la dépendance de ’modif’ (le ’modif∗ ’ indique une itération) ; exige un subordonnant gauche par la dépendance de ’det’, un subordonnant droit par la dépendance
de ’attr-rel’ et la dépendance entrante de ’dir-obj’ appelée aussi la tête de la catégorie. En fait, les catégories comme celle-ci, sont suffisantes pour décrire des dépendances projectives (également appelées les
dépendances locales).
Selon les propositions dans [Dik01a] et [Dik04] les dépendances discontinues sont définis par les types
polarisés de dépendance appelées les valences. Une valence positive indique le nom et la direction d’une
dépendance discontinue sortante. La valence négative correspondante avec le même nom a une direction
opposée et indique la fin de cette dépendance entrante (les deux valences sont dualles). Ainsi les dépendances discontinues sont indiquées par des paires de valences dualles.
22
Par exemple, le premier membre de la négation "ne... pas" en français, a le type [neg/( ր n-compound)]
dans laquelle la valence positive gauche (ր n-compound) exige que la dépendance n-compound du "ne"
soit sortante de gauche à droite. Respectivement, le deuxième membre a le type (ց n-compound). La
valence droite négative de (ց n-compound) exige que la dépendance de n-compound de "pas" soit entrante de gauche à droite. Ensembles ils constituent la dépendance discontinue de n-compound.
Il n’est pas difficile de voir que de telles valences ne suffisent pas pour exprimer la condition que la fin
d’une dépendance distante doit précéder ou être à côté d’un mot avec un certain type. Par exemple, dans
la phrase :
"It was yesterday that they had this meeting."
La dépendance discontinue it-cleft (it... that) sortante de la conjonction "that" doit positionner le pronom "it" juste avant le verbe principal. Pour exprimer cette condition, nous appliquons à ces valences les
primitives d’ancrage : # et ♭. En assignant à "It" le type #(ւ it-cleft) nous exigons que la dépendance
it-cleft doit entrer "it" de la droite et que la position de "it" doit être ancrée à un certain type ancré. Pour
que "was" soit le mot ancré(hôte) pour "it", nous lui assignons le type [♭(ւ it-cleft)\S/subj/circ]. Ce type
exige que la fin de la dépendance distante it-cleft doit immédiatement précéder "was".
Nous appelons catégories les types syntaxiques . Soit C un ensemble non vide de catégories élémentaires.
Les catégories élémentaires, comme subj, inf-subj, dobj, det, modif, etc. sont des noms de dépendances.
Les catégories élémentaires peuvent être itérées. Par exemple [a∗ ] dénote la catégorie itérative. Les catégories élémentaires et itérées sont locales.
Afin de définir les valences polarisées, nous présentons quatre polarités différentes : positif gauche et
positif droite : ր, տ (sortant de gauche (respectivement, droite) vers la droite (respectivement gauche))
et négatif gauche et négatif droite : ւ, ց (entrant de droite (respectivement gauche) vers la gauche (respectivement droite)). Pour chaque polarité v, il y a une unique polarité dualle v̆ :ւ=տ, տ=ւ, ր=ց
, ց=ր .
Les notations suivantes ւC, տC, րC et ցC definissent les ensembles correspondants de valences polarisées. V + (C) =րC ∪ տC est l’ensemble de valences positives, alors que V − (C) =ւC ∪ ցC est
l’ensemble de celles négatives. Intuitivement, les valences positives exigent les débuts des dépendances
discontinues, tandis que les valences négatives exigent leur fin.
Pour préciser les positions des fins des dépendances discontinues, nous employons deux modalités : #
(ancrant) et ♭ (ancré). Il y a des valences ancrées d’argument gauche et droit et les valences ancrants
correspondantes sont gauches et droites également.
Ancrél (C) = ♭l (α) | α ∈ V − (C), Ancrantl (C) = #l (α) | α ∈ V − (C),
Ancrér (C) = ♭r (α) | α ∈ V − (C), Ancrantr (C) = #r (α) | α ∈ V − (C),
Definition 1 Cat(C) est l’ensemble des catégories :
1. C ∪ V − (C) ∪ Ancrant(C) ⊂ Cat(C).
23
2. Pour C ∈ Cat(C), A1 ∈ (C ∪ C∗ ∪ Ancrél (C)∪ տ C) et A2 ∈ (C ∪ C∗ ∪ Ancrér (C)∪ ր C), les
catégories [A1\C] et [C/A2] appartiennent aussi à Cat(C).
CCat(C) ⊂ Cat(C) dénote l’ensemble des catégories qui n’ont pas de sous-catégories dans V − (C) ∪
V + (C). Ils s’appellent locaux.
Supposons que les opérateurs \ et / (back slash et slash) sont associatifs. Ainsi chaque catégorie complexe peut être représentée sous la forme suivante : [Lk\...L1\C/R1.../Rm].
3.2 Calcul de dépendances
Definition 2. Une grammaire catégorielle de dépendances (CDG) est un système G =(W, C, S, δ), où W
est un ensemble fini de mots, C est un ensemble fini de catégories élémentaires contenant la catégorie
choisie S, et le δ - appelé lexique - est une fonction sur W tels que δ(a) ∈ Cat(C) pour chaque mot a ∈ W.
Au-dessous , les indices des catégories sont leurs positions dans une séquence de catégories d’une phrase
donnée w = a1 ...an .
Definition 3. Une forme D-sentential d’une phrase W = a1 ...an ∈ W + est une paire (∆, Γ), où le ∆
est un graphe orienté avec l’ensemble de noeuds V = a1 , ..., an et un ensemble d’arcs marqués par des
catégories élémentaires, et Γ est une séquence non vide de catégories ordonnées.
Les formes D-sententiales (∆, S) sont terminaux.
Ici seulement les règles gauches sont présentées, les règles droites sont semblables.
Règle locale :
L. ((V, E), Γ1 C i [C\β]j Γ2 ) 7→ ((V, E ∪ {ai ← aj , C i }), Γ1 β j Γ2 ) pour C ∈ C.
Règles itératives :
I. ((V, E), Γ1 C i [C ∗ \α]j Γ2 ) 7→ ((V, E ∪ {ai ← aj , C i }), Γ1 [C ∗ \α]j Γ2 ) pour C ∈ C.
Ω. ((V, E), Γ1 [C ∗ \α]i Γ2 ) 7→ ((V, E), Γ1 αi Γ2 ) pour C ∈ C.
Règle des arguments des valences
V. ((V, E), Γ1 [β\α]i Γ2 ) 7→ ((V, E), Γ1 β i αi Γ2 ), où β ∈ Ancrél (C)∪ տ C est une valence.
Règle de dépendance d’ancrage :
A. ((V, E), Γ1 #l (α)i ♭l (α)j Γ2 ) 7→ ((V, E), Γ1 (α)i Γ2 ) pour #l (α) ∈ Ancrantl (C) et ♭l (α) ∈
Ancrél (C).
Règle de sub-commutativité :
C. ((V, E), Γ1 C i αj Γ2 ) 7→ ((V, E), Γ1 αj C i Γ2 ) if α ∈ (V − (C) ∪ V + (C) et
(i) C ∈ Ancré(C) ou
(ii) C ∈ Cat(C) et C n′ a pas d′ occurence de α, #(α), ♭(α) et ᾰ.
24
Règle des dépendances discontinues
D. ((V, E), Γ1 (ւ C)i (տ C)j Γ2 ) 7→ ((V, E ∪ {ai ← aj , Ci }), Γ1 Γ2 ) pour (տ C) ∈ տ C et
(ւ C) ∈ ւ C.
3.3 Expressivité
Les CDGs sont plus expressives que les grammaires non-contextuelles. Voici un exemple d’une CDG qui
produit le langage contextuel L(G0 ) = {d1 an d2 bn d3 cn | n > 0}, où par exemple n egal 3 (F IG . 3.4).
Soit G0 = ({a, b, c, d1 , d2 , d3 }, C0 , S, δ0 ), où δ0 est défini par :
a 7→ [♭l (ւ A)\#l (ւ B)], [♭l (ւ B)\#l (ւ B)],
b 7→ [տ B\D/C],
c 7→ [D\C],
d1 7→ [#l (ւ A)],
d2 7→ [♭l (ւ B)\(տ A)\S/D],
d3 7→ [D]
F IG . 3.4 – image créée par l’analyseur cdgAnalyst
Example 2 (F IG . 3.5)
das = [det],
Buch = [det\#l (ւ pre − dobj)],
hat = [♭l (ւ pre − dobj)\S/aux/subj/♭r (ւ pre − iobj)],
mir = #r (ւ pre − iobj),
P eter = [subj],
versprochen = [տ pre − iobj\aux/inf − dobj],
zu = [inf − dobj/zu − inf ],
lesen = [տ pre − dobj\zu − inf ].
25
F IG . 3.5 – arbre de dépendance
3.4 Complexité
S’il n’y a aucune limite supérieure sur le nombre de catégories élémentaires, alors l’analyse de CDGs
est un problème NP-complet. Heureusement, cette anomalie est impossible dans la pratique, parce que
l’inventaire des catégories élémentaires est fini et universel. Pour une liste des catégories élémentaires
voir l’annexe C.
Si le nombre des dépendances discontinues dans les phrases est uniformément borné par une constante
(ce qui est typique pour les langues naturelles), alors la complexité est O(n3 ) .
Il s’avère que pour analyser CDGs, il suffit de réaliser deux analyses indépendantes : la première en
termes de dépendances projectives et la deuxième en termes dépendances discontinues. Au-dessous sont
donnés les deux types de projections des catégories.
La projection locale kγkl d’une séquence γ ∈ Cat(C)∗ est définie comme :
l1. kεkl = ε; kCγkl = kCkl kγkl pour C ∈ Cat(C) et γ ∈ Cat(C)∗ .
l2. kCkl = C pour C ∈ C ∪ C∗ ∪ Anc(C).
l3. kCkl = ε pour C ∈ V + (C) ∪ V − (C).
l4. k[α]kl = kαkl pour tout α ∈ Cat(C).
l5. k[a\α]kl = [a\ kαkl ] et k[α/a]kl = [kαkl /a] pour a ∈ C ∪ C∗ ∪ H ôte(C) et α ∈ Cat(C).
l6. k[(տ a)\α]kl = k[α/(ր a)]kl = kαkl pour tout a ∈ C et α ∈ Cat(C).
La projection de valences kγkv d’une séquence γ ∈ Cat(C)∗ est définie comme :
v1. kεkv = ε; kCγkv = kCkv kγkv pour C ∈ Cat(C) et γ ∈ Cat(C)∗ .
v2. kCkv = ε pour C ∈ C ∪ C∗ .
v3. kCkv = C pour C ∈ V + (C) ∪ V − (C).
v4. k#(C)kv = C pour C ∈ V − (C).
v5. k[α]kv = kαkv pour tout [α] ∈ Cat(C).
v6. k[a\α]kv = k[α/a]kv = kαkv pour a ∈ C ∪ C∗ ∪ H ôte(C).
v7. k[a\α]kv = a kαkv , if a ∈ V + (C).
26
v8. k[α/a]kv = kαkv a, if a ∈ V + (C).
Exemples selon la définition 7.
k[♭l (ց c)\(տ a)\b\#r (ւ d)]kl = [♭l (ց c)\b\#r (ւ d)],
k[♭l (ց c)\(տ a)\b\(ւ d)/e]kl = [♭l (ց c)\b\ε/e],
k[♭l (ց c)\(տ a)\b\d]kv = տ a,
k[♭l (ց c)\(տ a)\b\#l (ւ d)/e]kv = տ a ւ d.
A part ces projections nous avons besoin d’une règle pour les valences. A cet égard ,ւ d et ր d jouent
le rôle des parenthèses gauches et տ d et ց d sont des parenthèses droites.
Définition 8. Soient G = (W, C, S, δ) une grammaire categorielle de dépendances, (α, ᾰ) une paire de
valence correcte et γ ∈ Cat(C)+ une séquence de catégories. Pour les deux valences β dans (α, ᾰ), |γ|β
signifie le nombre d’occurrences de β de la projection de valence kγkv . Les valeurs
∆L α(γ) = max{|γ ′ |ᾰ − |γ ′ |α | γ ′ est un préfix de γ},
∆R α(γ) = max{|γ ′ |α − |γ ′ |ᾰ | γ ′ est un suffixe de γ}
représentent respectivement le nombre de valences droites et gauches non éliminées de dépendances α.
Théorème. Soit G = (W, C, S, δ) une grammaire catégorielle de dépendances . χ ∈ L(G) si et seulement si, il y a une séquence de catégories γ ∈ δ(χ) telle que :
1.kγkl 7→∗p S,
2.kγkv est bien balancé.
Pour la preuve, voir [DD04].
3.5 Algorithme d’analyse pour CDG
L’algorithme que nous décrivons ci-dessous est un mélange des deux algorithmes classiques passés en
revue en chapitre 2. Il emploie une matrice triangulaire et parcourt les cellules comme CYK. Il emploie
des éléments qui représentent une partie reconnue de l’entrée comme Earley. Et il emploie la programmation dynamique comme les deux. Les modifications appliquées sont la manière dont les CDG appliquent
les règles et manipulent les dépendances discontinues et les types itérés.
Si C ∈ CCat(C), alors *-contraction(C) renvoie :
1. C et
2. Si C = [A∗ \α] ou C = [α/A∗ ] alors [α] est renvoyée aussi.
Pour une grammaire catégorielle de dépendances G = (W, C, S, δ), soit L = (α1 , ..., αp ) une liste
de toutes les valences gauches positives et négatives dans ւ C∪ ր C et R = (ᾰ1 , ..., ᾰp ) une liste de
toutes les valences droites positives et négatives dans տ C∪ ց C. Les éléments dans la matrice ont
la forme (I, lc, rc), où lc = (∆L α1 , ..., ∆L αp ) et rc = (∆R α1 , ..., ∆R αp ) sont des vecteurs des valeurs
des valences non éliminées (selon la définition 8) par rapport aux valences correspondantes αi ∈ L, et
27
ᾰi ∈ R. I = C (k) , où C ∈ CCat(C) ∪ ε, 1 ≤ k ≤ n. Evidemment C (k) correspond à SD(structure de
dépendance) de type C avec la position de racine k.
Les procédures SUBORDINATE_L et SUBORDINATE_R sont similaires, seulement une d’entre elles
est montrée.
Pour une optimisation de cet algorithme voir [DD05].
3.6 Pseudo-code
For 1 ≤ i ≤ n :
PROPOSE(i)
FORALL y ∈ δ(wi )
FORALL aj ∈ L
(lc)j = ∆L αj (y) ;
(rc)j = ∆R αj (y) ;
END_FORALL ;
FORALL C ∈ ∗ − contraction(kykl )
add (C (i) , lc, rc)toM [i, i]
END_FORALL
END_FORALL
END_PROPOSE
For 1 ≤ i ≤ j < k ≤ n :
SUBORDINATE_L(i, j, k)
(u)
FORALL (C1 , lc1 , rc1 ) ∈ M [i, j], and
(v)
(C2 , lc2 , rc2 ) ∈ M [j + 1, k]
FORALL m incrementally in 1 ≤ m ≤ p
(lc)m = (lc1 )m + max{0, (lc2 )m − (rc1 )m } ;
(rc)m = (rc2 )m + max{0, (rc1 )m − (lc2 )m } ;
END_FORALL ;
IF (C2 = [C1\y])
OR (C1 = #l (α) AN D C2 = [♭l (α)\y])
THEN
FORALL C ∈ ∗ − contraction(y)
add (C (v) , lc, rc) to M [i, k]
END_FORALL ;
ELSE_IF C2 = [C1∗ \y] OR C1 = ε
THEN
FORALL C ∈ ∗ − contraction(C2)
add (C (v) , lc, rc) to M [i, k]
END_FORALL ;
28
END_IF
END_FORALL
END_SUBORDINATE_L
Algorithm CdgAnalyst
Input : G ∈ L(CDG) and x = w1 ...wn
Output : "YES" iff x ∈ L(G).
FORALL m incrementally in 1 ≤ m ≤ n
PROPOSE(m)
END_FORALL ;
FORALL l incrementally in 1 ≤ l ≤ n − 1
FORALL i incrementally in 1 ≤ i ≤ n − l
k = i+l;
FORALL j incrementally in i ≤ j < k
SUBORDINATE_L(i, j, k) ;
SUBORDINATE_R(i, j, k) ;
END_FORALL
END_FORALL
END_FORALL ;
IF (S, (0, 0, ..., 0), (0, 0, ..., 0)) ∈ M [1, n]
THEN Output("YES")
ELSE Output("NO")
END_IF
Par exemple la grammaire catégorielle de dépendances G = (W, C, S, δ), où W = mot1, mot2, mot3, mot4,
C = {A, B, C}, δ(mot1) = [#l (ւ C)], δ(mot2) = [♭l (ւ C)\B], δ(mot3) = [B ∗ \S/A], δ(mot4) =
[տ C\A]. Let w = mot1 mot2 mot3 mot4. Au-dessous se trouve la structure syntaxique (F IG . 3.6) et
la matrice(TAB . 3.1). Les deux ont été génèrées automatiquement par l’algorithme d’analyse pour CDG.
F IG . 3.6 – arbre de dépendance
29
0 [#l(ւ C)]
#lc(0) #rc(1)
Map : #(0 -1 -1 -1)
Edges :
1 [B]
#lc(0) #rc(1)
Map : #(0 0 -1 -1)
Edges :
2 [S/A]
#lc(0) #rc(1)
Map : #(0 0 0 -1)
Edges :
(2 1 B local)
2 [B*\S/A]
#lc(0) #rc(1)
Map : #(0 0 0 -1)
Edges :
(2 1 B local)
1 [♭l(ւ C)\B]
#lc(0) #rc(0)
Map : #(-1 0 -1 -1)
Edges :
vide
2 [S/A]
#lc(0) #rc(0)
Map : #(-1 -1 0 -1)
Edges :
2 [B*\S/A]
#lc(0) #rc(0)
Map : #(-1 -1 0 -1)
Edges :
2 [S]
#lc(0) #rc(0)
Map : #(0 0 0 0)
Edges :
(2 1 B local)
(2 3 A local)
2 [B*\ S]
#lc(0) #rc(0)
Map : #(0 0 0 0)
Edges :
(2 1 B local)
(2 3 A local)
vide
2 [S]
#lc(1) #rc(0)
Map : #(-1 -1 0 0)
Edges :
(2 3 A local)
2 [B*\S]
#lc(1) #rc(0)
Map : #(-1 -1 0 0)
Edges :
(2 3 A local)
3 [A]
#lc(1) #rc(0)
Map : #(-1 -1 -1 0)
Edges :
TAB . 3.1 – la matrice génèrée pour w= mot1 mot2 mot3 mot4.
Le vecteur ’Map’ transforme l’algorithme de reconnaisseur à analyseur en gardant les positions initiales
pour la structure de dépendance.
Chapitre 4
AnalyseurGD/AlgoLR
4.1 Introduction
L’algorithme que nous allons décrire n’utilise pas la programmation dynamique, au contraire de CYK,
Earley et CDGAnalyst. On peut le classer comme un analyseur ascendant et dû à sa spécificité il n’est pas
sensible aux problèmes vu en chapitre 2.5. L’idée originale pour cet algorithme appartient à Alexander
Dikovsky et Michael Dekhtyar [DD01]. Ma contribution était d’élaborer l’algorithme pour la grammaire
catégorielle de dépendances et de résoudre ses faiblesses.
L’entrée de l’algorithme est une suite de catégories , renvoyée par l’automate de Markov Caché [Rab89],
[TM06] avec une probabilité assez grande. Cette suite se compose d’une catégorie grammaticale par
mot. Si elle échoue d’après AlgoLR, la deuxième suite la plus probable est tentée. Ce processus continue jusqu’à ce que la relation de Pbest /Pcourant soit plus petite qu’un seuil T. Pbest est la valeur de
la probabilité de la meilleur chaîne - avec la probabilité la plus élevée - et Pcourant est la probabilité
de la chaîne courante d’être analysée par AlgoLR. Nous avons pris la décision que pour T une valeur
de 100 est assez bonne. De cette manière on peut trouver les premières plus probables analyses correctes.
L’algorithme parcourt la suite de catégories de gauche à droite, catégorie par catégorie seulement une
fois. L’algorithme peut renvoyer ’Echec’ soit pendant le parcours soit à la fin. La structure syntaxique se
construit pendant le parcours de la suite de catégories. Si, à la fin, la séquence est reconnue comme une
phrase correcte, la structure syntaxique est renvoyée.
4.2 Structures de données
-LC est une pile contenant des categories de type CCat(C).
- vMC est une pile pour chaque C ∈ C et v ∈ {ր, ւ} . Il contient les positions des valences dans la
phrase.
- #l MvC , ♭r MvC sont des piles pour chaque C ∈ C et v ∈ {ւ, ց}. Ils contiennent les positions des
types ancrants et ancrés dans la phrase.
30
31
- HeadNC et SubNC montrent pour chaque C ∈ C, le nombre de fois où C apparaît également comme
dépendance entrante et dépendance sortante.
-T ryC et CurrentC . Pour chaque C ∈ C, T ryC indique le numéro de l’arc de type C qui doit être
formé. Alors que pour chaque C ∈ C, CurrentC indique le numéro courant d’un arc qui est en train
d’être analysé.
4.3 Description
L’algorithme AlgoLR analyse chaque catégorie de la même manière. Premièrement si la catégorie est
élémentaire et projective l’algorithme tente d’appliquer la règle locale de CDG entre elle-même(la catégorie) et le sommet de LC. Si ce n’est pas possible la catégorie est mise sur LC. C’est important de
mentionner qu’une règle est tentée seulement si une des deux catégories est élémentaire. Autrement selon la grammaire CDG ce n’est pas possible.
Si la catégorie est complexe alors les arguments subordonnés gauches sont analysés de gauche à droite,
un par un et les arguments droits de droite à gauche. Les éléments droits sont analysés seulement s’il n’y
a pas d’éléments gauches.
Chaque argument dans une catégorie complexe est testé dans l’ordre suivant : [C\β], [C ∗ \β], [(vC)\β],
[#x (vC)\β], [♭x (vC)\β], [β/C], [β/C ∗ ], [β/(vC)], [β/#x (vC)], [β/♭x (vC)]. Si l’argument courant
est local, la règle L est tentée sur lui-même et le sommet de LC. Si une dérivation n’est pas possible ,
l’algorithme arrête et renvoie ’Echec’ . Dans le cas contraire un arc est formé.
Si l’argument courant est itératif [C ∗ \β], deux catégories sont produites : [C ∗ \∅] et [β]. Ca correspond
à l’operateut ∗ − Contraction(C), dans l’algorithme précédant pour la règle itérative.
Si l’argument courant est : une valence gauche, un ancrant gauche ou un type ancré droite ; il est mis sur
sa pile.
Si l’argument courant est : une valence droite, un ancrant droite ou un type ancré gauche ; alors la règle
D de la grammaire CDG est tentée sur l’argument courant et le sommet de la pile correspondante. Si la
pile est vide, l’algorithme arrête et renvoie ’Echec’. Autrement un arc est formé.
Les arguments locaux droits sont analysés quand ils sont sur le sommet de LC.
32
4.4 Pseudo-code
%Algorithme AlgoLR
%Init.
α = a1 , ...an ;
CREATE_STACK(LC) ;
FOR_EACH C ∈ C DO
CREATE_STACK(vMC ) for v ∈ {ր, ւ} ;
CREATE_STACK(#l MvC , ♭r MvC ), for v ∈ {ւ, ց} ;
END_DO
FOR_EACH C ∈ C DO
CurrentC = 1 ; % numéro de l’arc courant
T ryC =1 ; % numéro de l’arc à construire
-calculer HeadNC
-calculer SubNC
END_DO
%Main Loop :
WHILE α 6= ε DO
IF α = ai β, 1 ≤ i ≤ n
THEN α = δ(ai )β ;
END_IF
LET α = C1j α′ ;
SELECT
%Simplification of C1j
CASE1 C1 = [C] f or some C ∈ C ∪ V − (C) ∪ Anc(C) ;
α = C j α′ ;
%Primitive category
CASE2 C1j = C
IF TOP(LC) = [β/C1 ]m
THEN
POP(LC) ;
E = E ∪ (am , aj , C1 ) ;
α = [β]m α′ ;
ELSE_IF TOP(LC) = [∅/β ∗ ]m
IF ( TOP(POP(LC)) = [β/C]r )
THEN
E = E ∪ {(ar , aj , C)} ;
POP(LC) ;
α = [β]r α′ ;
END_IF
ELSE_IF TOP(LC) = [∅/C ∗ ]m
E = E ∪ {(am , aj , C)} ;
33
α = α′ ;
ELSE
PUSH(LC, C1j )
α = α′ ;
END_IF
CASE 3. C1j = (vC) f or v ∈ {տ, ց}
IF v̆MC 6= ∅ AND TOP(v̆MC ) = m
THEN
POP(v̆MC ) ;
α = α′ ;
IF v = ց
THEN E = E ∪ {(am , aj , C)} ;
ELSE E = E ∪ {(aj , am , C)} ;
END_IF
ELSE
Output(FAIL) %Pas de prédécesseur gauche
END_IF
CASE 4. C1j = (vC) f or v ∈ {ր, ւ} ;
PUSH(vMC , j) ;
α = α′ ;
CASE 5. C1j = #x (vC) f or v ∈ {ւ, ց} ;
IF x = ”r”
IF TOP(♭x MvC ) 6= ∅
THEN POP(♭x MvC ); α = (vC)j α′ ;
ELSE Output(FAIL) ; %Pas de hôte gauche
END_IF
ELSE
PUSH(#xMvC , j) ;
END_IF
CASE 5.5 C1j = ♭x (vC) f or v ∈ {ւ, ց} ;
IF x = ”r”
THEN PUSH(♭x MvC , j); α = α′ ;
ELSE_IF TOP(#l MvC ) 6= ∅ = m
POP(#l MvC ); α = (vC)m α′ ;
ELSE
Output(FAIL) ; %Pas de ancrant gauche
END_IF
CASE 6. C1j = [C\β]
IF LC 6= ∅ AND TOP(LC) = [∅/β ∗ ]m
THEN POP(LC) ;
END_IF
IF LC 6= ∅ AND TOP(LC) = (C)r
THEN
E ∪ {(aj , ar , C)} ;
POP(LC) ;
34
α = [β]j α′ ;
ELSE
Output(FAIL) ; % Pas de prédécesseur gauche
Control_Fail(C) ;
END_IF
CASE 6.5 C1j = [C ∗ \β]
IF LC 6= ∅ AND TOP(LC) = [∅/β ∗ ]m
THEN toplc = TOP(LC) ; POP(LC) ;
END_IF
IF LC 6= ∅
WHILE ( TOP(LC) = (C)r )
POP(LC) ;
E ∪ {(aj , ar , C)} ;
IF(toplc 6= ε ) AND r < m
THEN toplc = ε ;
END_IF
END_WHILE
IF toplc = ε
THEN α = [β]j α′ ;
ELSE α = toplc[β]j α′ ;
END_IF
ELSE
α = [β]j α′ ;
END_IF
CASE 7. C1j = [(vC)\β] f or v ∈ {տ, ց}
α = (vC)j [β]j α′ ;
CASE 7.5 C1j = [#(vC)\β]
α = #(vC)j [β]j α′ ;
CASE 8. C1j = [♭x (vC)\β] f or v ∈ {ւ, ց} ;
α = ♭x (vC)j [β]j α′ ;
CASE 9. C1j = [β/C] f or C ∈ C
PUSH(LC, C1j ) ;
α = α′ ;
CASE 9.2 C1j = [∅/C ∗ ]
PUSH(LC, C1j ) ;
CASE 9.5 C1j = [β/C ∗ ]
α = [β]j [∅/C ∗ ]j α′ ;
CASE 10. C1j = [β/(vC)] f or v ∈ {ր, ւ} ;
α = [β]j (vC)j α′ ;
CASE 11. C1j = [β/#(vC)]
α = [β]j #(vC)j α′ ;
CASE 12. C1j = [β/♭x (vC)] f or v ∈ {ւ, ց} ;
α = [β]j ♭x (vC)j α′ ;
END_SELECT
35
END_WHILE
IF (LC = S) AND
(vMC = ε f or all C ∈ C and v ∈ {ր, ւ} ) AND
(#l MvC = ε, ♭r MvC = ε, f or all C ∈ C and v ∈ {ւ, ց} ) AND
( T = ( a1 , ..., an , E ) is a tree)
THEN Output(YES, T)
ELSE Output(Fail)
END_IF
CONTROL_FAIL(fail-cat)
%Le but de cette procédure est de déterminer s’il y a du sens
%à commencer un retour en arrière ou pas.
IF(SubNf ail−cat is itérative OR SubNf ail−cat = HeadNf ail−cat )
AND HeadNf ail−cat > 1
THEN
IF (T ryf ail−cat < HeadNf ail−cat )
THEN
T ryf ail−cat + + ;
BACK_TO(last_arc_of(f ail − cat)) ;
ELSE Return_Stop ; %Retour en arrière abandonné
ELSE Return_Stop ; % Retour en arrière abandonné
END_CONTROL_FAIL
Last_arc_of(f ail − cat)
- Trouver dans E le dernier arc de type f ail − cat, dont
le premier nœud < le deuxième nœud
- Si un tel arc n’existe pas,
Alors Renvoyer ECHEC
Sinon Renvoyer son deuxième nœud
END_OF_Last_arc_of
BACK_TO(sec-node-of-last-arc)
%Preparer LC
- supprimer tous les éléments avec des index plus grands ou égaux au
sec-node-of-last-arc
36
%Preparer les piles vMC , #MvC , ♭MvC
- supprimer tous les numéros plus grands ou égaux au sec-node-of-last-arc
%Preparer l’ensemble d’arcs E
- supprimer l’arc dernier du type échouant.
- supprimer tous les arcs dont le plus petit index est égal ou plus grand que le
sec-node-of-last-arc
- si existe un arc discontinu dont le plus petit index est plus petit que le
sec-node-of-last-arc et dont le plus grand index est plus grand que le
sec-node-of-last-arc, alors supprimer l’arc et mettre son plus petit index
dans vMC .
%Preparer le sommet de LC si nécessaire
-Si l’index de TOP(LC) égal first-node-of-last-arc
Alors Si TOP(LC) = [∅/C ∗ ] ou C est le type échouant,
Alors ne faire rien
Sinon PUSH(LC, {[∅/C], first-node-of-last-arc})
%Preparer la catégorie dont nous recommençons, si nécessaire
-prendre la catégorie initiale avec position dans la phrase sec-node-of-last-arc
-supprimer tous ses arguments gauches
END_BACK_TO
Où un arc est engendré on ajoute le code au-dessous pour que le retour en arrière puisse fonctionner.
C’est donné ici pour rendre le code plus facile à lire.
IF(CurrentC = T ryC )
THEN
- le code pour la création de l’arc avec les autres détails
ELSE
PUSH(LC, C1j ) ;
α = α′ ;
CurrentC = CurrentC + 1 ;
END_IF
37
4.5 Quelques faiblesses de l’algorithme
La première faiblesse de notre algorithme vient de la présence des types itérés (∗ ) qui d’après les grammaires catégorielles de dépendances peuvent être ignorés ou gardés pendant plusieurs dérivations. Nous
avons décidé de garder les types itérés aussi longtemps que possible et former toutes les relations de
dépendances qui sont possibles. Cette idée est réalisée de la manière suivante. Si l’argument courant est
itératif [β/C ∗ ] donc deux catégories sont produites : [β] et [∅/C ∗ ] . La catégorie [∅/C ∗ ] sera gardée sur
la pile LC tant que possible et l’autre catégorie [β] serait libre pour participer à d’autres dérivations.
Comme cela d’autres modifications supplémentaires de l’algorithme ne sont pas nécessaires.
Dans le cas où une dépendance locale enveloppe le type itéré ([∅/C ∗ ]) , alors le type itéré est supprimé
comme croisement des arcs projectifs n’est pas permis.
La deuxième faiblesse de l’algorithme est dûe à la façon de parcours de gauche à droite qui insiste d’employer des règles droites dans les situations de conflit. Par exemple la suite de catégories [C/D][D][D\E]
sera toujours réduite à [C][D\E]. Dans certains cas c’est bon mais dans d’autres c’est faux.
Il y a des suites de catégories qui ne peuvent pas être analysées de gauche à droite. Par exemple :
[S/D]1 ...[D]2 ...[D\a]3 ...[a\D]4
La première dérivation réduirait les deux premières catégories à [S]1 . Ensuite l’algorithme va lire la
troisième catégorie et va retourner ’Echec’ parce que l’argument D ne peut pas être éliminé. C’est un cas
où l’algorithme renvoie ’Echec’ alors que la phrase est grammaticalement correcte.
Dans ce cas nous proposons que l’algorithme effectue un retour en arrière jusqu’au [D]2 et essayer le
deuxième arc disponible - c’est à dire avec [D\a]3 en gardant le travail qui était déjà fait pour la partie
de la phrase avant [D]2 . Donc les dérivations prochaines sont :
1
4 L
[S/D]1 ...[a]3 ...[a\D]4 ⊢L
G [S/D] ...[D] ⊢G [S]
En fait cette technique fonctionne bien même s’il y a des arcs qui enveloppe [D]2 . Pour plus de détails
voir le pseudo code dans la section 4.4.
En fait, l’idée pour cette technique vient de la tentative de modéliser la manière dont les gens se débrouillent quand ils lisent et ne comprennent pas quelque chose. Ce qu’ils font est de retourner un peu
en arrière et puis de recommencer.
La méthode analyse avec succès des suites de catégories beaucoup plus compliquées. Par exemple
(F IG . 4.1) :
[S/D] [D] [D] [D\a] [a\D\a] [a∗ \D]
L’exemple du langage contextuel donné dans section 3.3 , fig.3.4 est aussi analysé sans problème.
Un exemple d’une dépendance enveloppant la catégorie de recommencement (la positions où le retour
38
F IG . 4.1 – arbre de dépendance
en arrière arrête) est donné au-dessous (F IG . 4.2).
[S/D/ ր V ] [D] [ց V ] [D\a] [a\D]
Pour plusieurs exemples et rapports complets voir l’annexe A.
Une autre faiblesse qui est présente dans d’autres algorithmes mais résolue ici est le phénomène d’avoir
une dépendance projective et une dépendance non-projective entrante dans le même mot. Pour resoudre
ça nous traitons les modalités d’ancrage(#, ♭) comme arguments distants et les plaçons dans la pile M
qui contient en général des types non-projectifs. Ca nous permet d’avoir une dépendance projective et
une ou plusieurs dépendances non-projectives entrante dans le même mot. Un exemple suit (F IG . 4.3 ) :
[a/#l (ւ V )/#l (ւ D)] [♭l (ւ D)\♭l (ւ V )\a\S/f ] [տ D\f /g] [տ V \g]
4.6 Un exemple détaillé.
AlgoLR fonctionne comme suit (nous montrons les états de LC, α et E seulement quand ils changent et
omettons quelques étapes insignifiantes, par exemple pour CASE 1).
39
0) LC = ∅ ; α = "Les vins bordellais sont excellents".
1) LC = ∅ ; α = det "vins bordellais sont excellents".
2) LC = det ; α = [det\subj/modif ] "bordellais sont excellents". (CASE 6)
3) LC = ∅ ; α = [subj/modif ] "bordellais sont excellents" ; E = {(Les, vins; det)} (CASE 9)
4) LC = [subj/modif ] ; α = modif "sont excellents". (CASE 2)
5) LC = ∅ ; α = subj "sont excellents" ; E = {(Les, vins; det), (vins, bordellais; modif )}.
6) LC = subj ; α = [subj\S/cop − adj] "excellents" ; (CASE 6)
7) LC = ∅ ; α = [S/cop − adj] "excellents" ; E = {(Les, vins; det), (vins, bordellais; modif ),
(sont, vins; subj)}.
8) LC = [S/cop − adj] ; α = cop − adj. (CASE 2)
9) LC = ∅ ; α = S ; E = {(Les, vins; det), (vins, bordellais; modif ), (sont, vins; subj),
(sont, excellents; cop − adj)}.
10) LC = S ; a = ∅.
L’arbre de dépendances est montré dans F IG . 4.4.
4.7 Complexité
La complexité de notre algorithme sans le retour en arrière est O(n) où n est le nombre de mots. Dans
une phrase le retour en arrière peut s’effectuer autant de fois qu’il y a des mots dans la phrase. Donc avec
le retour en arrière , la complexité dans le pire des cas est en théorie O(n(n + 1)/2) pour une phrase
grammaticalement incorrecte. Pour une phrase grammaticalement correcte la complexité est toujours
meilleure.
40
En pratique dans les langues naturelles le retour en arrière est un évènement très rare. Nous n’avons pas
rencontré plus qu’un retour en arrière dans la même phrase dans le corpus d’Emile Zola , où le style est
littéraire, les phrase très longues et compliquées. En fait dans le corpus d’Emile Zola avec 550 mots, le
retour en arrière est effectué seulement deux fois. En plus la longueur du retour est au maximum 2 ou 3
mots. Donc pour les langues naturelles, le retour en arrière est négligeable et la complexité reste linéaire.
Nous avons fait un test avec 200 phrases qui ont été analysées en 10 secondes ( cela inclut la création des
images et des rapports).
4.8 Rapport de fin d’analyse
A la fin de l’algorithme un rapport est créé, qui montre les détails pour chaque étape de l’algorithme.
Plusieurs rapports sont donnés à l’annexe A.
Le premier élément de chaque rapport donne l’information des principales étapes. Par exemple :
" Parsing successful ", " Trying to recover ", " Fail, no left headtype D ", " Init ".
"Init" signifie le début. C’est la première information renvoyée. Ensuite "Fail, no left argument D" signifie que l’analyseur n’a pas pu éliminer un argument droit de type D. "Trying to recover" signifie qu’un
retour en arrière est tenté. Enfin "Parsing successful" signifie réussite.
Dans le rapport nous avons affiché les états de toutes les structures (LC, E, vMC , α, HeadNC , SubNC ,
CurrentC , T ryC ). A la fin se trouve une section ’Debug’ qui montre avec beaucoup de détails chaque
pas que l’algorithme effectue.
Deux représentations graphiques de l’arbre de dépendance sont montrées aussi. La première est dessinée
avec SVG (Scalable Vector Graphics) qui fait partie de XML. Grâce à cela cette représentation est générée très très vite. La deuxième représentation est une image standard png. Elle est dessinée avec LISP en
utilisant une librairie en C. Malgré ça, la génération est très lente.
4.9 Implementation
L’algorithme incluant la création du rapport est réalisé entièrement en CLISP [KP94], [PS05]. Une exception fait seulement le module pour la création de l’image avec SVG.
Chapitre 5
La base de données et la structure du
système
5.1 Introduction
Le but principal de la BD est d’être un outil pour l’annotation et la correction des textes. Elle garde
des textes analysés syntaxiquement, morphologiquement, prosodiquement et sémantiquement. L’architecture de la base de données vise à faciliter l’annotation et la correction des phrases. Egalement, on peut
changer l’analyse correspondante à une phrase sans influencer l’analyse des autres phrases.
Avec l’interface on peut faire de nombreuses recherches : par mot, par trait syntaxique, par trait morphologique, par trait prosodique, par leur combinaison et par phrase. On peut aussi parcourir un corpus
particulier.
5.2 Représentation interne
En fait dans l’architecture interne de la BD pour chaque mot nous gardons la combinaison de trait syntaxique, trait morphologique, trait prosodique et trait sémantique. Nous pensons que cette information
sera utile pour tirer différentes conclusions sur les relations entre les traits(semantiques-syntaxiquesmorphologiques-prosodiques). Ca pourrait nous permettre d’extraire différentes caractéristiques pour
l’heritage des types et information statistique. Par exemple grâce à cette information le deuxième objectif de ce stage sera effectué très facilement. Pour le résultat voir annexe B.
Pour faciliter l’annotation et la correction nous avons relié chaque mot à la phrase d’où le mot vient. Pour
des détails sur l’architecture relationnelle voir le schéma au-dessous (F IG . 5.1).
41
42
F IG . 5.1 – structure de la BD
L’étoile(∗ ) indique qu’une table distincte est créée pour chaque langue.
L’architecture permet de faire l’insertion et la suppression d’enregistrements très rapidement puisque la
complexité de recherche dans une structure triée est log2 n.
5.3 Autres possibilités
La création de nouveaux langages, de nouveaux corpus et de nouveaux utilisateurs sont aussi implémentés. Ca permet à chaque utilisateur d’avoir ses propres corpus analysés dans la base de données et
personne ne pourrait les modifier à sa place.
Quand un corpus particulier est bien annoté, on peut l’exporter dans une forme optimisée qui peut servir
de dictionnaire pour l’analyseur CDGAnalyst.
La base de donnée est déjà sur le Net. On peut l’atteindre à l’adresse suivante http ://lexicon.freehostia.com.
Elle contient deux corpus, un texte scientifique pris de l’ensemble de textes de TAL et un texte littéraire
du roman de Emile Zola - Germinal. Les deux sont analysés syntaxiquement et morphologiquement
également avec 300 et 1000 mots. L’analyse syntaxique a été faite à l’aide de Alexandre Dikovsky et
Denis Béchet. L’étiquetage morphologique était fait automatiquement avec l’étiqueteur de Brill. Le corpus littéraire est étiqueté prosodiquement aussi (manuellement et automatiquement utilisant le système
de notation Intsint [MH00] est comme logiciel Praat) mais à ce jour l’étiquetage n’est pas inseré dans la
base de données.
En bref, la base de données pourrait servir comme outil pour développer les corpus étiquettés polyvalents
et les "treebanks" de dépendances, mais aussi pour les expérimentations de l’apprentissage supervisé des
43
CDG et pour le développement des analyseurs syntaxiques incrémenteaux.
5.4 Implementation
Comme base de données on a choisi MySQL[WT01], [JV04] à cause de sa popularité. L’interface pour
elle est réalisée en PHP.
5.5 Structure du système
Dans cette partie on présente le système complet d’analyse syntaxique, la phase d’apprentissage (F IG . 5.2)
et la phase d’exploitation (F IG . 5.3) . Le système complet se compose de 11053 lignes de code. Les fichiers sources du système complet sont téléchargeables à partir de lien :
http ://lexicon.freehostia.com/ParserLR+HMM.src.zip.
44
F IG . 5.2 – phase d’apprentissage
1. Un corpus brut (dans notre cas TAL et Zola).
2. Etiquetage prosodique qui peut être effectué manuellement ou automatiquement à l’aide des logiciels
libres MOMEL-INTSINT et Praat [MH00].
3. L’outil est déjà développé dans l’équipe TALN du LINA.
4. Cette analyse est effectuée par l’algorithme "CDGAnalyst" vu au chapitre 3. On a implémenté cet
algorithme en Lisp, en 2005 pendant un stage au LINA et était adapté pour nos buts pendant ce travail.
5. La base de données qui stocke les phrases analysées avec des informations hétérogènes fournis par 2,
3 et 4.
6. Le module d’apprentissage des CDG
7. Ce sont les fichiers crées par 6. qui contiennent des probabilités contextuelles (unigrammes, bigrammes
et trigrammes) et lexicales
45
F IG . 5.3 – phase d’exploitation
1. La phrase à analyser.
2. Les ressources lexicales préparées dans la phase d’apprentissage.
3. Etiquetage prosodique.
4. Etiqueteur de Brill.
5. L’automate de Markov est lancé.
6. L’analyseur de gauche à droite qui reconnaît si la phrase est correcte et construit les arbres de dépendances.
7. Cette étape montre les résultats finaux du processus(voir annexe A, rapport 2)
Chapitre 6
Conclusion et perspectives
Nous avons présenté ici la deuxième partie d’un système pour analyse syntaxique avec apprentissage
supervisé basé sur informations prosodiques et morphologiques. La première partie effectue l’apprentissage des grammaires CDG et la deuxième vérifie si les types syntaxiques affectés, forment une phrase
correcte et si oui renvoie son arbre de dépendances. Pendant ce stage nous avons conçu une base de données qui servira comme outil pour développer les corpus étiquettés polyvalents. Au cours de ce travail
nous avons élaboré un algorithme linéaire pour les grammaires catégorielles de dépendance. Nous avons
résolu plusieurs choses qui posent habituellement un problème pour l’analyse de ces grammaires. La
première est la présence des types itérés (∗ ) qui peuvent par définition former n’importe quel nombre
de dépendances locales. L’autre faiblesse vient de la manière dont l’algorithme effectue l’analyse - de
gauche à droite. Ca requiert que seulement les règles droites soient employées. Nous avons resolu aussi
le probléme d’avoir une dépendance projective et une ou plusieurs dépendances non-projectives entrante
dans le même mot. Mais malgré ces améliorations certaines situations problématiques peuvent apparaître.
A ce jour, nous n’avons pas rencontré une phrase grammaticalement correcte et en même temps évaluée par notre algorithme comme incorrecte. Tout de même, de telles situations peuvent se produire et
la cause peut provenir des types de dépendances itérés. Le problème est de déterminer le moment où
l’itération(la création des arcs sortantes du type itéré) doit s’arrêter. Par exemple dans la séquence :
[D] [D] [D] [D∗ \a] [a\D\S], l’itération du type ”D∗ ” ne doit s’effectuer que deux fois. Dans tous les
autres cas la séquence serait évaluée comme incorrecte. On pourrait résoudre ce problème en utilisant de
nouveau le retour en arrière, mais ça augmentera la complexité et rendra le code plus compliqué.
Une autre possibilité pour résoudre le problème ci-dessus serait de continuer l’itération (la création des
arcs sortantes du type itéré) jusqu’au nombre des arguments subordonnés du type itéré égale le nombre
de têtes (des catégories) du même type. Une autre proposition de contrôler la fin du processus d’itération est d’utiliser la prosodie et notamment les groupes intonatifs. Il est possible qu’elle va nous aider
à résoudre tous les problèmes décrits ci-dessus et en conséquence le retour en arrière ne serait plus nécessaire. La Recherche sur la prosodie de résoudre l’ambiguïté syntaxique est déjà faite [POSF], [CAL]
et les résultats sont prometteurs. Donc la création d’un oracle basé sur la prosodie pour guider l’analyse
des phrases est une des plus hautes priorités.
Ce qui concerne la première partie du système, nous pensons que la tache à accomplir dans le plus proche
future est de lexicaliser certaines observations parce que quand on remplace les mots par les catégories
affectées par l’étiqueteur de Brill, on perd de la précision. Par exemple la partie du discours PREP cor46
47
respond à plusieurs types syntaxiques comme prepos-à, prepos-de, prepos-vers, etc. (l’annexe C contient
tous les types syntaxiques élémentaires utilisés par le système). Comme conséquence, il peut arriver
qu’un type syntaxique soit affecté à une préposition non correspondante. Par exemple : de_[prepos-à].
Cela vaut la peine de faire plus de recherche sur d’autres méthodes d’apprentissage des CDG. Par
exemple Briscoe et Osborne [OB97] utilisent une sorte de grammaire catégorielle stochastique pour
apprendre la construction des arbre de dépendances et après composent les catégories de l’arbre généré.
Dans ce cas il n’y aura pas besoin d’un reconnaisseur syntaxique.
Nous avons remarqué qu’avec un analyseur standard tabulaire comme CDGAnalyst vu au chapitre 3, le
nombre d’analyses syntaxiques par phrase augmente avec la taille du dictionnaire. Evidemment la plupart de ces analyses sont sémantiquement fausses. Par ailleurs un analyseur statistique pourrait toujours
repérer l’analyse la plus correcte. Pour cette raison et bien d’autres ce travail mérite d’être poursuivi.
Annexe A
CDG Parser Left-to-Right Report 1
Status :
("Parsing successful !" "Trying to recover !" "Fail ! No left head type for subtype D" "Init.")
words
a1
a2
a3
a4
a5
used categories
[S/D ∗ / ր V ]
[D]
[ց V ]
[D\a]
[a\D]
Content of LC stack :
< [0/D∗ ], 0 > < [S], 0 >
Content of vMc stacks :
pl-V : NIL
Content of Debug stack
LC :
C1 : [S/D∗ /րV]
alpha : <[S/D∗ /րV], 0>
M:
48
49
Arcs :
After case 10 :
LC :
C1 : [S/D∗ ]
alpha : <[S/D∗ ], 0> <[րV], 0>
M:
Arcs :
After case 9.5 :
LC :
C1 : [S]
alpha : <[S], 0> <[∅/D∗ ], 0> <[րV], 0>
M:
Arcs :
After of case 2 :
LC : <[S], 0>
C1 : [0/D∗ ]
alpha : <[0/D∗ ], 0> <[րV], 0>
M:
Arcs :
After case 9.2 :
LC : <[0/D∗ ], 0> <[S], 0>
C1 : [րV]
alpha : <[րV], 0>
M:
Arcs :
After case 4 :
LC : <[0/D∗ ], 0> <[S], 0>
C1 : [D]
alpha : <[D], 1>
M:
pl-V : (0)
Arcs :
After of case 2 :
LC : <[0/D∗ ], 0> <[S], 0>
C1 : [ցV]
alpha : <[ցV], 2>
50
M:
pl-V : (0)
Arcs :
(0, 1, D, local)
After case 3 :
LC : <[0/D∗ ], 0> <[S], 0>
C1 : [D\a]
alpha : <[D\a], 3>
M:
pl-V : NIL
Arcs :
(0, 2, V, long distance)
(0, 1, D, local)
Retour en arriere a reussi pour type D ! ! !
After case 6 :
LC : <[0/D∗ ], 0> <[S], 0>
C1 : [D]
alpha : <[D], 1>
M:
pl-V : (0)
Arcs :
After of case 2 :
LC : <[D], 1> <[0/D∗ ], 0> <[S], 0>
C1 : [ցV]
alpha : <[ցV], 2>
M:
pl-V : (0)
Arcs :
After case 3 :
LC : <[D], 1> <[0/D∗ ], 0> <[S], 0>
C1 : [D\a]
alpha : <[D\a], 3>
M:
pl-V : NIL
Arcs :
(0, 2, V, long distance)
...
51
Report 2 (généré par le système entière)
Status :
("Parsing successful !" "Init." )
The correct sequence of states is :
Paths
[det] [det\pred] [pred\S/aux] [aux/circ/iobj]
[iobj/prepos-de] [prepos-de] [circ/prepos-vers] [quant]
[quant\prepos-vers]
Number of reliable paths tried : 1
Probabilities/ln(P)
1.51429895E-5
52
All possible sequences :
Paths
[quant\prepos-vers]
Probabilities
1.51429895E-5
[iobj/prepos-de] [iobj/prepos-de] [prepos-de] [circ/prepos-vers]
[quant] [quant\prepos-de]
8.220778E-7
[quant\prepos-à]
1.6244265E-8
[det] [det\pred] [pred\S/aux] [aux/circ/iobj] [iobj/prepos-de]
[prepos-de] [circ/prepos-vers] [quant] [prepos-de]
1.4438169E-8
[prepos-de] [circ/prepos-vers] [quant] [det\dobj]
1.1528404E-8
[prepos-de] [circ/prepos-vers] [quant] [det\attr]
3.74012E-9
[prepos-de] [circ/prepos-vers] [quant] [prepos-des]
3.74012E-9
[prepos-de] [circ/prepos-vers] [quant] [coord-conj]
1.2980504E-9
[prepos-de] [circ/prepos-vers] [quant] [ց compos-neg]
1.2980504E-9
[prepos-de] [circ/prepos-vers] [quant] [modif]
...
Le reste du rapport n’est pas montré.
4.840248E-10
...
Annexe B
Les types syntaxiques affectés aux classes des formes. Ceux-ci ont été extraits des deux corpus TAL et
Emile Zola - Germinal.
ACJ
[pred\S/coord/aux]
[circ\neg\explet\S/iobj]
[pred\S/coord/dobj/circ]
[neg\pred\coord-conj/dobj]
[iobj\accomp]
[coord-conj]
[prepos-de]
[prepos-au/iobj]
[ցattr/iobj]
[circ\circ]
[modif/coord]
[prepos-à]
[attr/circ]
[det\prepos-sur]
[restr\copul]
[det\pred]
[det\prepos-de]
[modif/attr]
[restr]
[compos]
[attr/circ*]
[attr]
[modif]
ADJ2PAR
[aux/inf-obj]
[modif/iobj]
[aux/րcirc]
[compos]
[ցattr/iobj]
[compar]
[rel/circ]
53
54
[modif]
[aux/circ/iobj]
[det\prepos-de]
[aux/dobj]
[modif/circ]
ADV
[ցcompos-neg]
[dobj/rel]
[circ/compos]
[quant\dobj]
[adverb]
[neg]
[restr]
[compos/adverb]
[circ/compos/adverb]
[circ]
[det\prepos-de/modif]
[տcompos-neg\neg]
[restr\ցcompos-neg]
[neg/րcompos-neg]
ANCFF
[inf-de/aux]
CAR
[coord-conj]
[quant/coord]
[adverb\quant/num]
[quant/րcirc]
[quant]
[num]
COO
[circ]
[coord/coord-conj]
DTC
[iobj/prepos-des]
[iobj/prepos-du]
[attr/prepos-au]
[attr/prepos-aux]
[iobj/prepos-au]
[circ/coord/prepos-au]
[attr/prepos-du]
[circ/prepos-au]
55
[attr/prepos-des]
[circ/compos]
[det]
[attr/coord/prepos-du]
DTN
[quant]
[clit-dobj]
[compos]
[dobj]
[quant/ւcompos-neg]
[det]
ECJ
[pred\S/accomp/aux]
[pred\coord/coord/circ/aux]
[pred\S/copul]
[pred\rel/circ/copul]
[prepos-de]
[pred\S/aux]
PREP
[oobj/prepos-sur]
[compos/compos]
[circ/inf-pour]
[attr/prepos-sur]
[dobj/inf-à]
[oobj/prepos-vers]
[compos/inf-de]
[dobj/prepos-de]
[iobj/coord/prepos-de]
[ցcirc/prepos-à]
[quant/prepos-de]
[attr/compos]
[aux/inf-obj]
[iobj/prepos-à]
[appos/prepos-de]
[circ/prepos-à]
[inf-obj/inf-de]
[circ/compos]
[circ/compos/prepos-à]
[circ/prepos-sur]
[circ/prepos-depuis]
[circ/prepos-après]
[coord-conj/prepos-sans]
[attr/coord/prepos-sans]
56
[ցcirc/compos]
[circ/prepos-pour]
[adverb/prepos-de]
[circ/prepos-contre]
[attr/prepos-à]
[circ/prepos-de]
[circ/prepos-vers]
[compos/prepos-de]
[circ/circ/prepos-avec]
[circ/inf-de]
[compar/prepos-sur]
[circ/prepos-par]
[iobj/prepos-de]
[circ/prepos-devant]
[circ/prepos-à-travers/compos]
[compos/prepos-à]
[attr/compos/prepos-de]
[attr/prepos-de]
[coord-conj/prepos-de]
[attr/coord/prepos-de]
[attr/prepos-sans]
[circ/prepos-sous]
[circ/prepos-dans]
PRO
[prepos-à]
[pred]
[circ/compos]
PRV
[circ]
[explet]
[prepos-de]
[pred/րattr]
[refl]
[pred]
[prepos-devant]
PUL
[circ/compos]
REL
[prepos-sur/rel]
[attr/rel]
[compos/prepos-où]
57
SBC
[quant\prepos-de]
[det\prepos-de/compos]
[quant\det\pred/attr]
[det\prepos-vers]
[ցcompos-neg]
[det\prepos-de/attr/iobj]
[det\ցappos/attr/modif]
[restr\det\pred/րappos]
[det\prepos-de/modif*]
[det\dobj/iobj]
[circ]
[quant\pred/modif]
[prepos-des/modif]
[quant\pred]
[det\pred/iobj]
[det\appos/attr/iobj/modif]
[det\copul/appos/modif]
[restr\det\attr\pred]
[det\prepos-à/modif]
[modif]
[prepos-du]
[det\prepos-à/attr]
[coord-conj]
[prepos-aux/modif]
[det\prepos-de/iobj]
[prepos-de/appos/modif]
[det\rel/րattr/attr]
[det\dobj/compos]
[modif\prepos-de]
[det\coord/attr*]
[det\dobj/coord]
[det\pred/modif]
[det\circ]
[prepos-au/inf-obj/modif]
[modif\prepos-au]
[quant\appos/attr]
[det\dobj/appos/modif]
[quant\prepos-à]
[det\prepos-depuis]
[det\attr]
[det\ցappos/attr]
[prepos-de/attr]
[det\dobj/attr/modif]
[modif\det\pred/րappos]
[det\pred/attr]
58
[det\appos/modif]
[compos\compos]
[quant\det\dobj/appos]
[prepos-au/attr]
[det\prepos-contre]
[det\prepos-dans/attr]
[modif\det\pred/rel]
[det\prepos-sous/attr/modif]
[quant\prepos-vers]
[prepos-des]
[det\prepos-de/attr/modif]
[compos/compos]
[det\prepos-avec/attr]
[det\dobj]
[quant\pred/attr]
[prepos-de/modif]
[det\dobj/attr]
[det\prepos-sur]
[det\coord/modif*]
[prepos-du/attr]
[det\prepos-par/attr]
[attr\det\prepos-de/modif]
[det\dobj/circ/iobj]
[det\dobj/modif]
[det\prepos-à-travers/attr]
[compos]
[num\appos/attr*]
[prepos-à]
[attr\det\dobj/appos/attr]
[det\pred]
[prepos-de]
[det\prepos-de/attr]
[det\prepos-de]
[prepos-sans]
[det\prepos-sous/attr*]
[det\prepos-dans/modif]
[circ]
[coord-conj/compar]
[coord/coord-conj]
[attr/compar]
SUB$
[compos/rel]
[attr/rel]
[ցcompos-neg]
59
VCJ
[pred\coord/circ/dobj]
[pred\circ§/coord/inf-obj/dobj]
[pred\coord/dobj/circ]
[rel/circ*/pred]
[refl\pred\circ\S/dobj/circ]
[aux/dobj]
[pred\circ\S/dobj]
[neg\pred\rel]
[pred\circ\coord-conj]
[modif]
[pred\S/coord/iobj]
[refl\prepos-où/pred]
[pred\circ\S/aux]
[pred\rel/circ*]
[pred\rel/dobj/circ]
[pred\circ*\S/circ*]
[refl\circ\coord/circ]
[pred\S]
[refl\pred\S]
[neg\pred\circ\coord/inf-obj]
[pred\circ\S/coord]
[pred\circ*\coord-conj/dobj]
[pred\circ\S/coord/circ]
[pred\S/dobj]
[pred\rel/inf-obj]
[dobj\pred\coord-conj/circ*]
[dobj\pred\S/coord/circ]
[pred\S/circ*]
[refl\pred\coord/circ]
[neg\pred\S/coord/dobj]
[neg\pred\circ\S/coord/dobj]
[pred\circ*\S/dobj/attr]
VNCFF
[inf-obj/oobj/dobj]
[inf-obj/circ]
[coord-conj/dobj]
[inf-pour/coord]
[inf-à/dobj]
[refl\inf-de/oobj]
[clit-dobj\inf-obj]
[refl\inf-de/dobj/circ]
[inf-obj/iobj]
[det\prepos-après/attr]
60
[inf-obj]
[prepos-pour/dobj/circ]
VNCNT
[attr/dobj]
[circ/circ]
Annexe C : Ensemble de types syntaxiques
Ci-dessous sont tous les types élémentaires utilisés par le système complet.
accomp
adverb
appos
attr
aux
circ
circ-telic
clit-dobj
compar
compos
compos-neg
coord
coord-compar
coord-conj
coord-cons
coord-premis
copul
copul-c
copul-q
det
dobj
explet
inf-à
inf-de
inf-obj
inf-pour
iobj
modif
neg
num
oobj
plus
pred
prepos-à
prepos-après
prepos-à-travers
prepos-au
prepos-aux
prepos-avec
prepos-contre
prepos-dans
prepos-de
prepos-depuis
prepos-des
prepos-devant
prepos-du
prepos-où
prepos-par
prepos-pour
prepos-sans
prepos-sous
prepos-sur
prepos-vers
quant
ref
refl
rel
restr
S
61
Bibliographie
[MP87] Igor Melchuk and Nikolaj Pertsov. Surface Syntax of English. John Benjamins Publishing Company, 1987
[SN97] Klaas Sikkel et Anton Nijholt. Parsing of context-free languages.Springer Verlag, Berlin 1997.
[JP00] Ingenierie des langues, sous la direction de Jean-Marie Pierrel, Hermes, 2000.
[JM00] D. Jurafsky & J. H. Martin, Speech and Language Processing, Prentice Hall, 2000.
[Dik01a] Alexander Dikovsky . Grammars for local and long dependencies. In Proc. Of the 39th Intern.
Conf. ACL’2001, pages 156-163. ACL & Morgan Kaufman, 2001
[Dik04] Alexander Dikovsky. Dependencies as categories. In G-J. Kruiff and D.Duchier , editors, Proc.
Of Workshop "Recent Advances in Dependency Grammars". In conjunction with COLING 2004,
pages 90-97, Geneva, Switzerland, August, 2004
[DD04] Michael Dekhtyar and Alexander Dikovsky. Categorical Dependency Grammars. In : Proc. of
Intern. Conf. on Categorical Grammars, Montpellier, France 2004.
[DD01] Michael Dekhtyar and Alexander Dikovsky. Incremental Analysis of Discontinuous Dependencies, 2001
[OB97] Miles Osborne and Ted Briscoe(1997). Learning Stochastic Categorical Grammars. CoNLL97 :
Computational Natural Language Learning, ACL pp 80-87
[POSF] P. Price, M. Ostendorf, S. Shattuck-Hufnagel, C. Fong. The use of prosody in syntactic disambiguation.
[DT07] Darin Todorov. Apprentissage des grammaires catégorielles de dépendances stochastiques à partir de phrases annotées avec des informations prosodiques. Rapport de stage M2R, ’Systeme d’aide
à la decision’ 2007
[DD05] Michael Dekhtyar et Alexander Dikovsky. Generalized Categorial Dependency Grammars(2005).
[KP94] Kent Pitman (ed). 1994. Programming Language Common Lisp(ANSI/X3.226-1944)
[PS05] Peter Seibel. (2005). Practical Common Lisp. Apress 2005.
[WT01] Luke Welling and Laura Thompson. Php and MySQL development. Sams Publishing, Indiana
46290
[JV04] Janet Valade. Php & MySQL for dummies 2004, Wiley publishing, Inc., Indiana
[MS99] Chritopher D. Manning et Hinrich Schutze. Foundations of Statistical Natural Language Processing. Massachusetts Institute of Technology 1999.
[CAL] J.P. Tubach (ed), La parole et son traitement automatique par Calliope, 3-146. Masson et CNETENST, Paris, 1989.
62
63
[MH00] M. Horn (ed), Prosody : Theory and experiments, 51-58. 2000 Kluwer Academic Publishers.
Printed in the Netherlands.
[Rab89] Lawrence Rabiner. (1989). A Tutorial on Hidden Markov Models and Selected Applications in
Speech Recognition. Proc. IEEE, 77 (2), 257-286.
[TM06] Tobias Mann. (2006). Numerically Stable Hidden Markov Model Implementation.
Sommaire
1 Introduction
5
2 Types d’analyseurs
2.1 Arbres de dépendances et arbres de constituants. . . .
2.2 Le processus d’analyse syntaxique . . . . . . . . . .
2.3 Analyse de haut en bas et ascendant . . . . . . . . .
2.4 Comparaison entre les deux méthodes . . . . . . . .
2.5 Problèmes avec les algorithmes d’analyse syntaxique
2.6 L’algorithme CYK(Cocke-Younger-Kasami) . . . . .
2.7 L’algorithme d’Earley . . . . . . . . . . . . . . . . .
2.8 Algorithmes d’analyse tabulaire . . . . . . . . . . .
2.9 Optimisations et autres algorithmes . . . . . . . . . .
2.9.1 L’algorithme de Graham, Harrison, et Ruzzo
2.9.2 L’algorithme de de Vreught et Honing . . . .
2.9.3 L’algorithme de Rytter . . . . . . . . . . . .
2.10 Grammaires de dépendances et de constituants . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
9
9
10
10
12
14
17
17
18
18
18
19
3 Grammaire Catégorielle de Dépendances (CDG)
3.1 Types synataxiques ( catégories ) . . . . . .
3.2 Calcul de dépendances . . . . . . . . . . . .
3.3 Expressivité . . . . . . . . . . . . . . . . . .
3.4 Complexité . . . . . . . . . . . . . . . . . .
3.5 Algorithme d’analyse pour CDG . . . . . . .
3.6 Pseudo-code . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
20
20
23
24
25
26
27
4 AnalyseurGD/AlgoLR
4.1 Introduction . . . . . . . . . . . . .
4.2 Structures de données . . . . . . . .
4.3 Description . . . . . . . . . . . . .
4.4 Pseudo-code . . . . . . . . . . . . .
4.5 Quelques faiblesses de l’algorithme
4.6 Un exemple détaillé. . . . . . . . .
4.7 Complexité . . . . . . . . . . . . .
4.8 Rapport de fin d’analyse . . . . . .
4.9 Implementation . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
30
30
30
31
32
37
38
39
40
40
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
i
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
ii
5 La base de données et la structure du système
5.1 Introduction . . . . . . . . . . . . . . . .
5.2 Représentation interne . . . . . . . . . .
5.3 Autres possibilités . . . . . . . . . . . . .
5.4 Implementation . . . . . . . . . . . . . .
5.5 Structure du système . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6 Conclusion et perspectives
Annexes
Sommaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
41
41
42
43
43
46
i
I NSTITUT
DE
R ECHERCHE
EN I NFORMATIQUE DE
NANTES
Analyse syntaxique des grammaires
catégorielles de dépendances stochastiques
Hristian Todorov
(encadré par Alexandre Dikovsky et Denis Béchet)
Résumé
Le but de ce travail est de présenter la deuxième partie d’un système expérimental d’apprentissage supervisé, ainsi qu’une base de données qui va servir pour le dictionnaire du système. Elle va contenir
des corpus analysés syntaxiquement, morphologiquement et avec des traits prosodiques. La première
partie du système repose sur l’apprentissage stochastique des grammaires catégorielles de dépendances,
alors que la deuxième partie consiste d’un algorithme en temps linéaire pour effectuer la construction de
l’arbre syntaxique. En bref le système utilise des connaissance de differents niveaux pour apprendre le
syntaxe.
Termes généraux : analyse syntaxique, grammaires catégorielles de dépendances, types de dépendances
projectives et non-projectives.
Mots-clés additionnels et phrases : traitement automatique du langage naturel
LINA, Faculté des Sciences & Techniques de Nantes
B.P. 92208 — F-44322 NANTES CEDEX 3

H.Todorov - Freehostia.com

Transcription

Documents pareils

Organigramme

UN BRIN D`HERBE DANS LA CAMPAGNE Le slogan de la

INDUSTEEL FRANCE Site du Creusot

Nouvelles addictions sans substance: de l

science et technique - Beit al

Fiche descriptive

sources des figures et des tableaux

F - IMO