The MetaGrammar Compiler: An NLP Application with a Multi-paradigm Architecture

Transcription

1 The MetaGrammar Compiler: An NLP Application with a Multi-paradigm Architecture Denys Duchier Joseph Le Roux Yannick Parmentier LORIA Campus cientifique, BP 239, F Vandœuvre-lès-Nancy, France MOZ Conference, 7 8 October, 2004

2

3

4 Developing large and practical grammars Grammars to build realistic NLP applications Lexicalized tree grammars N N* N V N N V N... eats John eats the apple eats (John) who eats the apple The lexicon maps each word to a set of alternative syntax trees

5 tructural redundancy affects maintenance and extensibility N V N N V PP John eats eats the apple V V P N is eaten by The apple is eaten by John hare and modularize information in the lexicon Automatically generate the lexicon from descriptions

6 haring information We consider tree fragments N V Intuition: combination of these fragments to obtain trees The combination process must be based on linguistic observations:, Regularities among verb trees (e.g. number of arguments) Realizations of verbal arguments (e.g. canonical, extracted, etc) V...

7 2 axis of grammar description (part 1) Tree structure sharing (fragment combinations) 1. John sleeps Canonicalubject ActiveVerb IntransitiveVerb N V 2. John eats the apple + = V N V Canonicalubject ActiveVerb CanonicalObject TransitiveVerb N V + + = V V N N V N

8 2 axis of grammar description (part 2) Alternative choices (e.g. to express paraphrases) CanonicalObject: John eats the apple. WhObject: Which apple does John eat?... CanonicalObject WhObject Object = or or... V N N

9 Our approach Tree fragments are represented by logic formulæ of a tree description language V N ( V ) ( N) (V N) Encapsulation of the tree fragments into classes 1. tructure sharing through multiple inheritance 2. Alternative choices through explicit disjunctions We obtain a DAG of classes: the metagrammar (MG)

10 1. tructure sharing VerbalMorphology V Active Passive V V V V V

11 1. tructure sharing VerbalMorphology V Canonical_ubject N V Active Passive V V V V V Canonical_Act N V V

12 2. Alternative choice Canonical_ubject Active V N V V Extracted_ubject N Canonical_Act N V V Extracted_Act N V V Intransitive_Act Canonical_Act OR Extracted_Act

13

14 Content of a class everal dimensions: yntactic dimension tree descriptions emantic dimension predicate logic... These dimensions share identifiers (logic variables) In the syntactic dimension, an identifier can refer to a node, or a feature In the semantic dimension, an identifier refers to either a predicate or an argument

15 Identifier scope Default scope of an identifier: the class How to reuse information contained in a class? We use a mechanism to import and export identifiers Exported identifiers can be renamed This mechanism prevents name conflicts An object-oriented way of handling identifier scope

16 Tree descriptions Intransitive Verb N V P(A) class IntransitiveVerb <syn> { node [cat=s]; node V[cat=v,pred=P]; node N[cat=n,arg0=A]; -> V; -> N; N << V } <sem> {P(A)}

17

18 From MG to logic programs MG Class = Name and Linguistic Info Info = Tree fragment, Class call, Alternation, Combination Valuated classes Logic Program Clause ::= Name Goal Goal ::= Description Name Goal Goal Goal Goal Queries Lexicon generation as the execution of the MG/program

19 DCGs tarting with words as descriptions, i.e. with a CF-grammar: NP VP VP V NP NP the N, V chased N rabbit wolf The following Prolog program recognizes the same language: s(in,out):- np(in, Mid),vp(Mid, Out).... v(in,out):- term( chased, In, Out). term(x,[x L],L). (In-Out is called the accumulator)

20 EDCGs Extended DCGs [Van Roy, 1990]: Generalized accumulation (logic or algebraic operation) Multiple accumulators In our case: 2 Dimensions: yntax and emantics Accumulation of tree descriptions and logic formulæ with unification

21

22 tep 1: Compilation Translate the concrete syntax into symbolic code: 1. MG tokenization and parsing: GUMP 2. Intermediate syntax tree checking: pre-compilation warnings / failures 3. Compilation of the intermediate code into symbolic code (records)

23 tep 2: An object-oriented virtual machine Execution of the symbolic code by a specific virtual machine (VM) A standard logic programming kernel (inspired by the Warren s Abstract Machine) An object-oriented VM: each record of the code corresponds to a method (easily extendible)

24 Why a new VM? 1. Easier to extend: non-standard data types (e.g. open feature structures or nodes) non-standard unification (e.g. polarities in Interaction Grammars), 2. Output of the VM: snapshot of the accumulators semantic dimension: accumulated formula syntactic dimension: accumulated tree description Computing models of a tree description Constraint solver

25 tep 3: A constraint-based tree description solver Computing of all minimal models of a tree description, Dominance constraint solver based on a set constraint approach [Duchier - Niehren, 2000], In a model, the position of a node is given by the values of 5 set variables: Eq x, Up x, Down x, Left x, Right x Up Left Eq Right x y [EqUp x Up y Down x EqDown y Left x Left y Right x Right y ] Down

26 Colors Precise control on fragment combinations Coloration of each node with a color {Black, Red, White} Restrictions on how colored nodes can be combined: a red node does not combine with another node a black node combines only with 0 or more white nodes a white node must combine with a black node

27 A node in the model a set of nodes in the description: singleton (red nodes) set composed of 1 black node and 0 or more white nodes This set contains only one non-white node, we introduce a variable RB x Additional constraints: x V r RB x = x Eq x = {x} x V b RB x = x x V w RB x V b

28 Output of the solver trees printed in an XML file a Qtk GUI

29

30 First results Device adaptable to grammars based on tree descriptions (TAG and IG for now) The compiler has been used by linguists to generate a large scale Lexicalized TAG (more than 3,000 trees produced from 175 classes) Automatically generated lexicons used for parsing (TAG: LORIA LTAG Parser2, DyALog system, IG: LEOPAR)

31 To sum up 2-level multi-paradigmity: User level: Mixing Object Oriented (MG architecture) and Logic Programming (unification mechanisms) Internal level: VM implemented in an OO way + Constraint programming Current work: modularization of the constraint solver extension to other formalisms (e.g. XDG)