Språkgranskningsverktyg, vt 2008

Transkript

1 , vt 2008 Föreläsning 7 Chartparsning i allmänhet och UCP i synnerhet evapet@stp.lingfil.uu.se 1

2 Djupstruktur och ytstruktur Jag läste en bok igår Igår läste jag en bok 2

3 Chartparsning - bakgrund Utvecklades i slutet av 60-talet och början av 70-talet (Martin Kay och Ron Kaplan) Generell datastruktur för satsanalys Utforskar alla alternativa analyser vid varje steg i parsningsprocessen Alla alternativa analyser sparas i en chart (av eng. tabell/diagram/grafisk bild) Delanalyserna kan sedan användas vid lösning av större segment i satsen 3

4 Chartparsning Den centrala datastrukturen i en chartparser är en chart En chart är en riktad graf, som består av noder (vertices) och bågar (edges) Noderna utgörs av ord eller tecken Bågarna är aktiva eller passiva: aktiva bågar representerar delanalyser under uppbyggnad (regeltillämpningar och partiellt analyserade konstituenter) passiva bågar representerar kompletta (del)analyser 4

5 Samspelet mellan aktiva och passiva bågar (1) Analysen byggs upp genom ett samspel mellan aktiva och passiva bågar Chartparsningens fundamentala lag: När en aktiv båge träffar på en passiv båge (dvs den högraste noden i en aktiv båge är samma nod som den vänstraste noden i en passiv båge) bildas ett bearbetningssteg, en task Bearbetningsstegen läggs på en agenda (scheduling) Från agendan hämtas de för exekvering (selecting) i den ordning som bestämts av systemet 5

6 Samspelet mellan aktiva och passiva bågar (2) Ett bearbetningssteg involverar alltid exakt en aktiv och en passiv båge Utförandet av ett bearbetningssteg leder vanligen till nya bågar och nya bågkonstellationer, som genererar nya bearbetningssteg När agendan är uttömd är parsningen avslutad Resultatet av en komplett parsning representeras av en passiv båge från första till sista noden 6

7 Processkontroll Bearbetningen i en chartparser styrs av: tillståndet i charten principer för scheduling och selection bredden först (i den ordning de skapades) djupet först (vänstraste/högraste symbolen först) Formalismens uppgift bygga strukturbeskrivningar i form av särdragsstrukturer införa nya bågar i charten och därmed föra bearbetningen framåt 7

8 UCP (Uppsala Chart Parser) UCP1/UCP2 skrivet i LISP chartparsning tecken för tecken lexikonsökning, stavelseanalys, morfologisk och syntaktisk analys UCP2 används på labben UCP3 (UCP light) mindre och snabbare variant, konverterad till C chartparsning ord för ord hanterar syntaktisk analys (lexikon hanteras av andra moduler) används för t.ex. maskinöversättning 8

9 Tillämpningar av UCP böjnings- och sammansättningsanalys för lexikonbyggande grammatikkontroll SCARRIE Scania Checker maskinöversättning Convertus-systemet (föregångare: Multra, MATS) ordpredicering Fasty-projektet 9

10 Uppbyggnad av charten i UCP UCP bygger en initial passiv chart av inputsträngen och lägger in en aktiv båge från och till startnoden Fortsatt uppbyggnad av charten styrs av regler i språkbeskrivningen, dvs i lexikon och grammatik start.rule är ett reserverat namn på den regel som inleder parsningen 10

11 Bågar i UCP alla bågar i en UCP-chart innehåller uppgift om ursrpungstask (creator) start- och slutnod aktiva bågar innehåller en särdragsstruktur (features) med ett toppsärdrag & passiva bågar innehåller en särdragsstruktur (features) med ett toppsärdrag * aktiva bågar innehåller en LR-Action (regelsekvens eller lexikonpekare) en initial aktiv båge går från och till sig själv 11

12 Exempel på en UCP-regel (define sve.gram-entry np_noun #u <* word.cat> = 'NOUN, <& phr.cat>:=:'np, <& numb> :=: <* numb>, <& gender>:=:<* gender>, <& case>:=:<* case>, <& def>:=:<* def>, <& head lem>:=:<* lem>, <& head word.cat>:=:<* word.cat>, store; #! word.cat; ) 12

13 Exempel på en passiv båge 1--7 Creator: 112 Features: (* = (START = 1 END = 7 PHR.CAT = NP NUMB = SING GENDER = UTR CASE = BASIC DEF = DEF HEAD = (WORD.CAT = NOUN LEM = SOL.NN))) 13

14 Exempel på en UCP-regel (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; ) 14

15 Exempel på en aktiv båge 1--7 Creator: 78 Features: (& = (PHR.CAT = CL TYPE = MAIN MODE = DECL NP = (START = 1 END = 7 PHR.CAT = NP NUMB = SING GENDER = UTR CASE = BASIC DEF = DEF HEAD = (LEM = SOL.NN WORD.CAT = NOUN)))) LR-Action: <* PHR.CAT> = 'VP, <* INFF> = 'FIN, <& VP> :=: <*>, STORE, MAJORPROCESS(SENT); 15

16 Regelformat (define grammatiknamn-entry regelnamn #u rule.body; #! passivt.filter; #! aktivt.filter; ) (define sve.gram-entry np_noun #u <* word.cat> = 'NOUN, <& phr.cat>:=:'np, <& numb> :=: <* numb>, <& gender>:=:<* gender>, <& case>:=:<* case>, <& def>:=:<* def>, <& head lem>:=:<* lem>, <& head word.cat>:=:<* word.cat>, store; #! word.cat; ) 16

17 Konstanter och särdragsstrukturer Konstanter, dvs atomiska värden i en särdragsstruktur, föregås av ' Bågar skrivs inom < > (define sve.gram-entry np_noun #u <* word.cat> = 'NOUN, <& phr.cat>:=:'np, <& numb> :=: <* numb>, <& gender>:=:<* gender>, <& case>:=:<* case>, <& def>:=:<* def>, <& head lem>:=:<* lem>, <& head word.cat>:=:<* word.cat>, store; #! word.cat; ) 17

18 Operatorer i UCP operatorer för test och tilldelning av attribut och värden operatorer för kontroll operatorer för att införa nya bågar i charten 18

19 Operatorer för test och tilldelning Likhetsoperatorn: attribut = värde testar att två särdragsstrukturer är ekvivalenta om attributet är ospecificerat eller har ett annat värde än det som står till höger om likhetsoperatorn så misslyckas regeln Unifieringsoperatorn: attribut :=: värde testar och tilldelar på samma gång om attributet är ospecificerat tilldelas det värdet till höger om unifieringsoperatorn om attributet har ett annat värde än det som står till höger om unifieringsoperatorn så misslyckas regeln 19

20 Operatorer för test och tilldelning (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; ) 20

21 nil-värdet atomen nil betecknar underspecificerade värden ordformen barn kan vara antingen singular eller plural, och kan därför initialt tilldelas nil-värdet för sitt numerussärdrag vid unifiering med en struktur där värdet är specificerat, skrivs nil-värdet över med det specificerade värdet 21

22 Operatorer för kontroll (1) konjunktion: expr1,..., exprn uttryck åtskilda med kommatecken testas i sekvens om ett uttryck misslyckas, testas inte följande uttryck, utan hela regeln misslyckas 22

23 Konjunktion (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; ) 23

24 Operatorer för kontroll (2) beroende disjunktion: expr1 /... / exprn uttryck åtskilda med / testas i sekvens om ett uttryck i disjunktionen misslyckas, testas följande uttryck istället om ett uttryck i disjunktionen lyckas, testas inte följande uttryck rekommenderas att disjunktionen skrivs inom parentes: (expr1 /... / exprn) 24

25 Beroende disjunktion (define sve.gram-entry np_noun #u <* word.cat> = 'NOUN, <& phr.cat>:=:'np, (<& numb> :=: 'plur/<& numb> :=:'sing), <& gender>:=:<* gender>, <& case>:=:<* case>, <& def>:=:<* def>, <& head lem>:=:<* lem>, <& head word.cat>:=:<* word.cat>, store; #! word.cat; ) 25

26 Operatorer för kontroll (3) oberoende disjunktion: expr1 //... // exprn uttryck åtskilda med // testas var och en för sig, oberoende av varandra rekommenderas att disjunktionen skrivs inom parentes: (expr1 //... // exprn) 26

27 Oberoende disjunktion (define sve.gram-entry np_noun #u <* word.cat> = 'NOUN, <& phr.cat>:=:'np, (<& numb> :=: 'plur//<& numb> :=:'sing), <& gender>:=:<* gender>, <& case>:=:<* case>, <& def>:=:<* def>, <& head lem>:=:<* lem>, <& head word.cat>:=:<* word.cat>, store; #! word.cat; ) 27

28 Operatorer för kontroll (4) villkorssatser: if condition then expr1 else expr2 om villkoret condition är uppfyllt, så utförs expr1, annars utförs expr2 else-satsen är optionell 28

29 Villkorssatser (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; ) (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, if (<* word.cat>='verb, <* inff>='fin) then (<& verb>:=:<*>, store) #! phr.cat or word.cat; ) 29

30 Sanningsvärden och negation continue (sant) failure (falskt, regeln misslyckas) not (negation) if (not <* numb>='sing) then continue else failure 30

31 Operatorer för kontroll (5) regelanrop: regelnamn(arg1,..., argn) bearbetar den anropade regeln innan nästa instruktion utförs argument är optionella om argument skickas med, kan de anropas från den nya regeln med hjälp av indexerade variabler:?1,?2,?3 etc. 31

32 Regelanrop (define form.dic-entry "studenten" #u noun.entry('student.nn, 'utr, 'sing, 'def, 'basic); ) (define sve.gram-entry noun.entry #u end.of.word, <& word.cat>:=:'noun, <& lem> :=:?1, <& gender> :=:?2, <& numb> :=:?3, <& def> :=:?4, <& case> :=:?5, majorprocess(np_noun), store.form; ) 32

33 Operatorer för att skapa nya aktiva bågar (1) process(arg) startar en ny process i ändpunkten på den aktiva bågen i aktuell task arg utgörs av namnet på en grammatikregel (define sve.gram-entry start.rule #u process(form.dic), majorprocess(cl.decl); #! char; ) 33

34 Operatorer för att skapa nya aktiva bågar (2) majorprocess(arg) startar en ny process i startpunkten på den aktiva bågen i aktuell task (define sve.gram-entry noun.entry #u end.of.word, <& word.cat>:=:'noun, <& lem> :=:?1, <& gender> :=:?2, <& numb> :=:?3, <& def> :=:?4, <& case> :=:?5, majorprocess(np_noun), store.form; ) 34

35 Operatorer för att skapa nya aktiva bågar (3) advance(arg) för pågående process vidare genom att lägga in en ny aktiv båge från startpunkten i den aktiva bågen i aktuell task till slutpunkten i den passiva bågen 35

36 advance (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; ) 36

37 Operatorer för att skapa nya passiva bågar (1) store(arg) lagrar resultatet av bearbetningen i aktuell task genom att lägga in en ny passiv båge från startpunkten i den aktiva bågen till slutpunkten i den passiva bågen ( konsumerar den passiva bågen) 37

38 store (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; ) 38

39 Operatorer för att skapa nya passiva bågar (2) minorstore(arg) lagrar resultatet av bearbetningen i aktuell task genom att lägga in en ny passiv båge från startpunkten i den aktiva bågen till dess slutpunkt 39

40 Grammatikkontroll med UCP Lokala felregler ReportChart Chartscanner som söker efter felsärdrag i charten Tre grundläggande principer: Simplicity Principle Sök endast efter fel på toppnivån i särdragsstrukturen Longest Span Principle Välj alltid den längsta analysen Right-Before-Wrong Principle Om det finns flera analyser av samma längd, så välj alltid en analys utan fel i framför en analys med fel i 40

41 ett student - brott mot genuskongruens i NP (define sve.gram-entry np_art_noun #u <& phr.cat> :=: 'np, <* word.cat> = 'art, <& art> :=: <*>, advance, <* word.cat> = 'noun, (<& art gender> :=: <* gender> / <& err :new> :=: 'np-gender), <& head> :=: <*>, store; #! word.cat; ) (setq *error-acts* '(:VAL (np-gender. "Brott mot genuskongruens i NP") (felkod1. "beskrivning av felet") (felkod2. "beskrivning av ett annat fel") ))

42 ett student - brott mot genuskongruens i NP (* = (START = 1 END = 13 NUMB = SING GENDER = NEUTR DEF = INDEF PHR.CAT = NP DET = (LEM = EN.AL WORD.CAT = ART) ERR = (1 = NP-GENDER) CASE = BASIC HEAD = (LEM = STUDENT.NN WORD.CAT = NOUN)))

43 Uppärvning av särdrag Chartscannern söker endast efter felsärdraget på toppnivån i charten Felsärdrag som ligger på fraser under toppninvån måste ärvas upp till toppnivån för att ge effekt ett student NP-kongruensfel pluggar verb deklarativ huvudsats NP + verb 43

44 ett student pluggar - inga felmeddelanden från grammatiken! (define sve.gram-entry np_art_noun #u <& phr.cat> :=: 'np, <* word.cat> = 'art, <& art> :=: <*>, advance, <* word.cat> = 'noun, (<& art gender> :=: <* gender> / <& err :new> :=: 'np-gender), <& head> :=: <*>, store; #! word.cat; ) (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; )

45 (* = (START = 1 END = 21 PHR.CAT = CL TYPE = MAIN MODE = DECL SUBJ = (START = 1 END = 13 NUMB = SING GENDER = NEUTR DEF = INDEF PHR.CAT = NP DET = (LEM = EN.AL WORD.CAT = ART) ERR = (1 = NP-GENDER) CASE = BASIC HEAD = (LEM = STUDENT.NN WORD.CAT = NOUN)) VERB = (START = 13 END = 21 WORD.CAT = VERB LEM = PLUGGA.VB DIAT = ACT INFF = FIN TENSE = PRES VERB.TYPE = MAIN)))

46 ett student pluggar - brott mot genuskongruens i NP (define sve.gram-entry np_art_noun #u <& phr.cat> :=: 'np, <* word.cat> = 'art, <& art> :=: <*>, advance, <* word.cat> = 'noun, (<& art gender> :=: <* gender> / <& err :new> :=: 'np-gender), <& head> :=: <*>, store; #! word.cat; ) (define sve.gram-entry cl.decl #u <& phr.cat>:=:'cl, <& type>:=:'main, <& mode>:=:'decl, <* phr.cat>='np, <* case>:=:'basic, <& subj>:=:<*>, (<& subj err>, <& err>:=:<& subj err>/ not <& subj err>), advance, <* word.cat>='verb, <* inff>='fin, <& verb>:=:<*>, store; #! phr.cat or word.cat; )

47 (* = (START = 1 END = 21 PHR.CAT = CL TYPE = MAIN MODE = DECL SUBJ = (START = 1 END = 13 NUMB = SING GENDER = NEUTR DEF = INDEF PHR.CAT = NP DET = (LEM = EN.AL WORD.CAT = ART) ERR = (1 = NP-GENDER) CASE = BASIC HEAD = (LEM = STUDENT.NN WORD.CAT = NOUN)) ERR = <* SUBJ ERR> VERB = (START = 13 END = 21 WORD.CAT = VERB LEM = PLUGGA.VB DIAT = ACT INFF = FIN TENSE = PRES VERB.TYPE = MAIN)))

48 Referenser Anna Sågvall Heins föreläsningsbilder från Maskinöversättning och språkgranskning 2006 Weijnitz, Per: Uppsala Chart Parser Light System Documentation, in Working Papers in Computational Linguistics & Language Engineering 12 Sågvall Hein, Anna: A Test Version of the Grammar Checker for Swedish, in Working Papers in Computational Linguistics & Language Engineering 12 48