03 tag 2 - uni-potsdam.de · baumadjunktionsgrammatiken • baumadjunktionsgrammatik (tree...

Baumadjunktionsgrammatiken II

Vorlesung “Grammatikformalismen” Alexander Koller

29. April 2016

Natürliche Sprachen in der Chomsky-Hierarchie

reguläreAusdrücke

O(n)

Turing-maschinen

unentscheidbar

kontextfreieGrammatiken

O(n3)

kontextsensitive Grammatiken

PSPACE-vollst.

schwachkontextsensitiveGrammatiken

O(nk)

Parsingkomplexität

Expressivität

poly

nom

iell

expo

nent

iell

✘

✘ ✘

✘

Baumadjunktionsgrammatiken

• Baumadjunktionsgrammatik (tree adjoining grammar, TAG): endliche Menge von Elementarbäumen, und zwar ‣ Initialbäumen: Elementarbäume wie in TSG

‣ Auxiliarbäume: Elementarbäume, in denen genau ein Blatt ein Fußknoten ist

• TAG-Ableitungen: in jedem Schritt ‣ Substitution eines Initialbaums, oder

‣ Adjunktion eines Auxiliarbaums

Übersicht

• Expressivität von TAG

• Parsing

• Wahrscheinlichkeitsmodell

Expressivität von TAG

• Jede kfG kann man in stark äquivalente TSG übersetzen (nicht unbedingt lexikalisiert).

• Jede TSG kann man in schwach äquivalente kfG übersetzen.

A ! B a C DB↓ a

A

C↓ D↓

liebt◊

NP↓ VP

S

V NP↓S ! NP liebt NP


• Konsequenz: TSG ist schwach kontextfrei.

• TAG kann auch nicht-kf. Sprachen beschreiben. ‣ z.B.: Copy-Sprache { ww | w ∈ Σ* }

‣ auch Sprache COUNT(4) = { an bn cn dn | n ≥ 1 }

‣ aber nicht COUNT(5) = { an bn cn dn en | n ≥ 1 }

• COUNT-Sprachen allgemein: COUNT(k) = { a1n a2n ... akn | n ≥ 1 }

TAG für die Copy-SpracheCOPY = { ww | w ∈ Σ* }

a S

S

a

b S

S

b

b S

S

S* S

b

a S

S

S* S

a

NA NA NA

NA

NA

NA


a S

S

a

b S

S

b

b S

S

S* S

b

a S

S

S* S

a

a S

S

a

NA NA NA

NA

NA

NA

NA


a S

S

a

b S

S

b

b S

S

S* S

b

a S

S

S* S

a

a S

S

a

a S

S

a

b S

S S

b

NA NA NA

NA

NA

NA

NA

NA

NA

NANA


a S

S

a

b S

S

b

b S

S

S* S

b

a S

S

S* S

a

a S

S

a

a S

S

a

b S

S S

b

a SS

a

b S

S Sb

c SS S

c

NA NA NA

NA

NA

NA

NA

NA

NA

NA

NA

NA

NA

NANA

NA

NA NA

KfG für COUNT(2)COUNT(2) = { an bn | n ≥ 1 }

S → a S b | a b

• KfGs können an einer einzigen Stelle den String “aufpumpen”. Die neuen Terminale müssen alle beieinander stehen.

• TAG: Mit Adjunktion den Baum aufpumpen. Neue Blätter müssen im String nicht nahe beieinander stehen.

TAG für COUNT(4)

a S

Sd

b c

a S

Sd

b cS*

NA NA

NA

TAG für COUNT(4)

a S

Sd

b c

a S

Sd

b cS*

NA NA

NA

a S

Sd

b c

NA

TAG für COUNT(4)

a S

Sd

b c

a S

Sd

b cS*

NA NA

NA

a S

Sd

b c

NA

a

S

Sd

b c

NA

a S

Sd

b cNA

NA

TAG für COUNT(4)

a S

Sd

b c

a S

Sd

b cS*

NA NA

NA

a S

Sd

b c

NA

a

S

Sd

b c

NA

a S

Sd

b cNA

a

S

Sd

b c

NA

a

S

Sd

b c

NA

a S

Sd

b c

NA

NA

NA

NA


• TAG kann mehr Sprachen beschreiben als kfG, insbesondere: ‣ Fernabhängigkeiten (≈ COUNT(4))

‣ Cross-serial dependencies (≈ COPY)

• TAG kann aber nicht alle kontextsensitiven Sprachen beschreiben. ‣ Z.B. nicht COUNT(5); kann man mit TAG-Variante des

Pumping-Lemmas zeigen.

‣ Idee: TAG kann zwei Stellen im String gleichzeitig aufpumpen, aber nicht drei.

Parsing von TAG

• Wenn TAG expressiver ist als kfG, kann man dann noch effizient parsen?

• Antwort: es geht polynomiell. Hier: CKY-Parser.

• CKY-Parser verlangt binäre TAG-Grammatiken: Jeder Knoten in jedem Elementarbaum hat höchstens zwei Kinder.

Parsing von TSG: 1. Ansatz

• Konvertiere jeden Elementarbaum als Ganzes in schwach äquivalente kfG-Regel:

• Verwende normale CKY-Regel für nicht-binäre kfGen.

liebt◊

NP↓ VP

S

V NP↓

S ! NP Aliebt NP

Aliebt ! liebt

[B1, i1, i2] . . . [Br, ir, ir+1] A ! B1 . . . Br

[A, i1, ir+1]

Komplexität

• Elementarbaum mit r Blättern: Regel enthält r+1 Variablen für Stringpositionen.

• Daher ist Laufzeit O(nr+1).

• Das ist zu langsam.

[B1, i1, i2] . . . [Br, ir, ir+1] A ! B1 . . . Br

[A, i1, ir+1]

TSG-Parsing, 2. Ansatz

• Grundidee aus CNF-Transformation für kfGen: Binarisierung ‣ r-stellige Regel in r 2-stellige Regeln aufbrechen

‣ damit sinkt Rang r auf 2 ⇒ Laufzeit O(nr+1) = O(n3)

• Für TSG mit binären Elementarbäumen bietet es sich an, entlang der Baumstruktur aufzubrechen.

Gut aufpassen

• Die naive Lösung klappt nicht:

• Man könnte dann Teile verschiedener Elementarbäume miteinander kombinieren.

NP↓ VP

S

NP↓liebt◊VP

S → NP VPVP → NP VPVP → liebt

NP↓ VP

S

schläft◊

S → NP VPVP → schläft

Pfade in Bäumen

• Man kann jeden Knoten in einem Baum mit einem Wort aus N* beschreiben, das sagt, wie man von der Wurzel aus hinkommt.

• Diese Wörter heißen manchmal auch Gorn-Adressen.

liebt◊

NP↓ VP

S

V NP↓

ε1 2

21 22

211

Buchführen über Bäume

S ! NP↵11 VP↵1

2

VP↵12 ! V↵1

21 NP↵122

V↵121 ! liebt

NP↵11 ! NP NP↵1

22 ! NPliebt◊

NP↓ VP

S

V NP↓

ε1 2

21 22

211

Lösung: eigene NT-Symbole für jeden Elementarbaum.

[V↵121 , i, j] [NP↵1

22 , j, k]

[VP↵12 , i, k]

[B1↵⇡1, i1, i2] . . . [Bn

↵⇡r, ir, ir+1]

[A↵⇡ , i1, ir+1]

Bsp. CKY-Regelinstanz: Allgemein:

CKY-Parser für TSG

• Statt in Nichtterminalen kann man sich die Knoten auch direkt in den Parse-Items merken.

• Wir hatten r ≤ 2 angenommen, daher Laufzeit: O(n3).

[B1, i1, i2,↵,⇡1] . . . [Br, ir, ir+1,↵,⇡r]

[A, i1, ir+1,↵,⇡]conc11

[A, i1, i2,↵0, ✏] ⇡ Substitionsknoten in ↵ mit Label A

[A, i1, i2,↵,⇡]subst

Jetzt zu TAG

a S

S

a

b S

S

S* S

b

c S

S

S* S

c

NA NA

NA

NA

NA

α1

[S, 4, 5,↵1, 2] [S, 5, 6,�1, 22]

[S, 4, 6,�1, 2]

1. Versuch:

β1 β2 a SS

a

b S

S Sb

c SS S

c

1 2

3

4 5 6

7

Jetzt zu TAG

a S

S

a

b S

S

S* S

b

c S

S

S* S

c

NA NA

NA

NA

NA

α1

[S, 4, 5,↵1, 2] [S, 5, 6,�1, 22]

[S, 4, 6,�1, 2]

[S, 2, 7,�1, ✏]

.

.

.

1. Versuch:

β1 β2 a SS

a

b S

S Sb

c SS S

c

1 2

3

4 5 6

7

Jetzt zu TAG

a S

S

a

b S

S

S* S

b

c S

S

S* S

c

NA NA

NA

NA

NA

α1

[S, 4, 5,↵1, 2] [S, 5, 6,�1, 22]

[S, 4, 6,�1, 2]

[a, 1, 2,↵1, 1] [S, 2, 7,↵1, 2]

[S, 1, 7,↵1, ✏]

[S, 2, 7,�1, ✏]

.

.

.

.

.

.

1. Versuch:

β1 β2 a SS

a

b S

S Sb

c SS S

c

1 2

3

4 5 6

7

Jetzt zu TAG

a S

S

a

b S

S

S* S

b

c S

S

S* S

c

NA NA

NA

NA

NA

α1

[S, 4, 5,↵1, 2] [S, 5, 6,�1, 22]

[S, 4, 6,�1, 2]

[a, 1, 2,↵1, 1] [S, 2, 7,↵1, 2]

[S, 1, 7,↵1, ✏]

[S, 2, 7,�1, ✏]

.

.

.

.

.

. ? ? ?

1. Versuch:

β1 β2 a SS

a

b S

S Sb

c SS S

c

1 2

3

4 5 6

7

Problem

• Bei einer Adjunktion von β in α verarbeitet Parser erst mal β und “vergisst”, dass er noch den Rest von α verarbeiten muss.

• Eine Lösung: Items enthalten Stack von unverarbeiteten Baumteilen.

• Führt aber zu exponentieller Laufzeit. ‣ Zeige ich Ihnen in einer analogen Situation bei CCG.

CKY-Parser für TAG

• Zwei Typen von Items: ‣ [A,i,k,α,π]: Abgeleiteter Baum unter Knoten π in α deckt

vollständigen String von i bis k ab (wie in TSG).

‣ <A,i,j,k,l,β,π>: Abgeleiteter Baum unter π in β deckt String von i-j sowie String von k-l ab; dazwischen ist “Lücke”.

4 5

a S

S

a

b S

S S

b

12

3

a S

S

a

b SS

S* S

b

α1

β1

hS, 2, 3, 4, 5,�1, ✏i [S, 3, 4,↵1, 2]

[S, 2, 5,↵1, 2]

TAG-Parser: Regeln

hA, i1, i2, i3, i4,�, ✏i [A, i2, i3,↵,⇡]

[A, i1, i4,↵,⇡]wrap21

NB: “foot” leitet Items für beliebige i, k ab.

Knoten ⇡ von ↵ ist Wort wi

[wi, i, i+ 1,↵,⇡]lex

Knoten ⇡ von � ist Fußknoten A⇤, und i < k

hA, i, i, k, k,�,⇡i foot

TAG-Parser: Regeln

[B, i1, i2,�,⇡1] hC, i2, i3, i4, i5,�,⇡2ihA, i1, i3, i4, i5,�,⇡i

conc12

hB, i1, i2, i3, i4,�,⇡1i [C, i4, i5,�,⇡2]

hA, i1, i2, i3, i5,�,⇡iconc21

hA, i1, i2, i5, i6,�1, ✏i hA, i2, i3, i4, i5,�2,⇡ihA, i1, i3, i4, i6,�2,⇡i

wrap22

Beispiel

a S

S

a

b S

S

S* S

b

c S

S

S* S

c

NA NA

NA

NA

NA

α1 β1 β2 a SS

a

b S

S Sb

c SS S

c

1 2

3

4 5 6

7

[S, 1–2,↵1, 1]

[S, 2–3,�1, 1]

(aus �2)

hS, 3–4, 6–7,�2, ✏ihS, 4–4, 5–5,�1, 21i [S, 5–6,�1, 22]

hS, 4–4, 5–6,�1, 2iconc21

hS, 3–4, 5–7,�1, 2iwrap22

hS, 2–4, 5–7,�1, ✏iconc12

[S, 4–5,↵1, 2]

[S, 2–7,↵1, 2]wrap21

[S, 1–7,↵1, ✏]conc11

Diskussion

• Laufzeit: Teuerste Regel ist wrap22. Sechs unabhängige Stringpositionen, also O(n6).

• Kann Algorithmus auf TAG-Grammatiken mit mehr als zwei Kindern pro Knoten erweitern (analog Earley-Parser für kfGs).

• Algorithmus erlaubt mehrfache Adjunktion am gleichen Knoten. Kann man verbieten: Item merkt sich, ob schon adjungiert wurde.

Probabilistische TAG

• Grundidee: Zufallsprozess baut Ableitungsbaum top-down.

• Mögliche Ereignisse (statistisch unabhängig): ‣ Ableitung mit Baum α anfangen

‣ Substitutionsknoten A↓ mit Baum α füllen

‣ An Knoten mit Label A den Baum β adjungieren

‣ An Knoten mit Label A nichts adjungieren

• Jedes Ereignis bekommt eigene W.

Probabilistische TSG


α1

A A


α1

A A

Initialw. PI(α1) = 0.3


α1

A A


X

↵

PI(↵) = 1


α1

A A


X

↵

PI(↵) = 1

α2


α1

A A


Substitutionsw. PS(α2 | A) = 0.4

X

↵

PI(↵) = 1

α2


α1

A A



X

↵

PI(↵) = 1

α2

fur alle A:X

↵

PS(↵|A) = 1


α1

A A



X

↵

PI(↵) = 1

α2 α3

fur alle A:X

↵

PS(↵|A) = 1


α1

A A


Substitutionsw. PS(α2 | A) = 0.4 PS(α3 | A) = 0.6

X

↵

PI(↵) = 1

α2 α3

fur alle A:X

↵

PS(↵|A) = 1


AA


AA

β1

A

A*


AA

β1

A

A*Adjunktionsw. PA(β1|A) = 0.2


AA

β1

A


fur alle A:X

↵2Aux[{none}

PA(↵|A) = 1


AA

β1

A


Nicht-Adjunktionsw. PA(none|A) = 0.8

fur alle A:X

↵2Aux[{none}

PA(↵|A) = 1


AA

β1

A


Nicht-Adjunktionsw. PA(none|A) = 0.8

P (↵1(�1)) = PI(↵1) · PA(�1|A) · PA(none|A) = 0.048

fur alle A:X

↵2Aux[{none}

PA(↵|A) = 1

Algorithmen

• Algorithmen übertragen sich von PCFGs: ‣ Parsing: TAG-CKY-Parser + Viterbi

‣ Training: Maximum Likelihood, EM

• Training: ‣ Nichtstatistische TAG vorgeben + EM-Training

‣ KfG-annotiertes Korpus in TAG-Korpus konvertieren

‣ Problem: In Penn Treebank werden Komplemente und Adjunkte nicht unterschieden.

der Hund rennt

Det N

NP VP

S

Algorithmen für PTAG

• Parsing-Accuracy für PTAG vergleichbar mit lexikalisierten PCFG-Parsern (Chiang 2000).

• Grammatikeinträge in LTAG sind alle lexikalisiert. Daher sehr sparse data, Smoothing wird ganz wichtig.

• Hoher Grad an lexikalischer Ambiguität macht Parsing langsam. Übliche Lösung: Supertagging (Srinivas 1997).

Große TAG-Grammatiken

• XTAG-Grammatik: Große TAG-Grammatik für English. www.cis.upenn.edu/~xtag

• Grammatik für Französisch in Entwicklung.

• Größere Mengen Arbeit auch an Deutsch, Koreanisch.

http://www.cis.upenn.edu/~xtag

Zusammenfassung

• Expressivität von TAG: kann COPY, COUNT(4), nicht mehr COUNT(5)

• Parsing von TAG: mit CKY-artigem Parser in O(n6).

• Probabilistische TAG: übernimmt Grundideen von PCFG.

03 tag 2 - uni-potsdam.de · baumadjunktionsgrammatiken • baumadjunktionsgrammatik (tree...

Documents