Der CKY-Parser. Vorlesung Computerlinguistische Techniken Alexander Koller. 27. Oktober 2015

Transkript

1 Vorlesung omputerlinguistische Techniken Alexander Koller 27. Oktober 2015

2 Übersicht Komplexität des KY-Algorithmus Implementierung in Python

3 hift-reduce-parsing hift-regel: (a w, s) (w, s a) Reduce-Regel: (w, s w ) (w, s A) falls A w in P tart: (w, ε) Wende Regeln nichtdeterministisch an, bis Zustand (ε, ) erreicht ist

4 hift-reduce: Ein Problem T T b b c T c * T * T * T * T * T * T etc. R-Erkenner muss für tring der Länge n bis zu 2 n Kombinationen durchprobieren.

5 Laufzeitvergleich def quadratic_issorted(l): for i in range(len(l)): for j in range(i+1, len(l)): if L[j] < L[i]: return False return True Laufzeit len(l) quadratic linear ms 0.02 ms ms 0.1 ms sec 1.2 ms def linear_issorted(l): for i in range(len(l)-1): if L[i] > L[i+1]: return False return True sec 13 ms 179 ms n 2 45 ns n 120 ns

6 O-Notation Asymptotische Laufzeit eines Algorithmus: Abstrahiert über Implementierungsdetails. eien f, g Funktionen. Definition: f = O(g) gdw. ex. c, n 0 mit f(n) c g(n) f.a. n n 0 Man nimmt normalerweise kleinstes g, für das f = O(g).

7 Laufzeitklassen Worst-ase-Laufzeit von hift-reduce: 2 n erechnungsschritte (n ist Länge des trings). Exponentialfunktion wächst schneller als jedes Polynom: Es gibt kein k, so dass 2 n = O(n k ).

8 Was ist das Problem? Warum braucht der R-Parser exponentielle Laufzeit? Zwischenergebnisse werden mehrfach berechnet. Können wir das vermeiden? * * * * T T T T

9 Auswege Für top-down: Memoisierung. peichere frühere berechnete Zwischenergebnisse in Tabelle und schlage sie beim zweiten Aufruf nach. Für bottom-up: Dynamisches Programmieren (auch bekannt als hart-parsing): Algorithmus arbeitet direkt auf einer Tabelle (der hart).

10 Einfachster hartparser für kfgs in NF. Erfunden in den 1960ern von ocke, Younger, Kasami; heißt manchmal auch YK-Parser. erechnet bottom-up Aussagen der Form A * w i... w k-1?.

11 NP VP NP Det N VP V NP V isst NP Hans Det ein N Käsebrot Hans isst ein Käsebrot

12 NP VP NP Det N VP V NP V isst NP Hans Det ein N Käsebrot Hans isst ein Käsebrot. Hans isst ein Käsebrot

13 NP VP NP Det N VP V NP V isst NP Hans Det ein N Käsebrot Hans isst ein Käsebrot. Anfangsposition Hans isst ein Käsebrot

14 NP VP NP Det N VP V NP V isst NP Hans Det ein N Käsebrot Endposition Hans isst ein Käsebrot. Anfangsposition Hans isst ein Käsebrot

15 NP VP NP Det N VP V NP V isst NP Hans Det ein N Käsebrot hart Endposition Hans isst ein Käsebrot. Anfangsposition Hans isst ein Käsebrot

16 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP Anfangsposition Hans isst ein Käsebrot

17 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP V Anfangsposition Hans isst ein Käsebrot

18 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP V Det Anfangsposition Hans isst ein Käsebrot

19 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP V Det N Anfangsposition Hans isst ein Käsebrot

20 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP V NP Det N Anfangsposition Hans isst ein Käsebrot

21 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP V NP Det N Anfangsposition Hans isst ein Käsebrot

22 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP VP V NP Det N Anfangsposition Hans isst ein Käsebrot

23 NP VP V isst Det ein NP Det N NP Hans N Käsebrot VP V NP hart Endposition Hans isst ein Käsebrot. NP VP V NP Det N Anfangsposition Hans isst ein Käsebrot

24 a a a a a a a

25 a a a a a a a

26 a a a a a a a

27 a a a a a a a

28 a a a a a a a

29 a a a a a a a

30 a a a a a a a

31 a a a a a a a

32 T T b b c T c

33 T T b b c T c

34 T T b b c T c

35 T T b b c T c

36 T T b b c T c

37 T T b b c T c T

38 T T b b c T c T

39 T T b b c T c T

40 T T b b c T c T

41 T T b b c T c T T

42 T T b b c T c T T

43 T T b b c T c T T

44 T T b b c T c T T T

45 T T b b c T c T T T

46 T T b b c T c T T T T

47 KY-Parser: Algorithmus Datenstruktur: h(i,k) enthält Menge aller Nichtterminale A mit A * w i... w k-1 (anfangs überall leer). für alle i von 1 bis n: für alle Produktionen A w i : füge A zu h(i, i+1) hinzu für alle b von 2 bis n: für alle i von 1 bis n-b+1: für alle k von 1 bis b-1: für alle h(i, i+k) und h(i+k,i+b): für alle Produktionen A : füge A zu h(i,i+b) hinzu

48 KY-Parser Erkenner: Wort in prache gdw am chluss das tartsymbol in h(1,n+1) steht. Parser: Muss sich für jeden Eintrag in der Tabelle merken, wie man ihn aus kleineren Einträgen bauen kann.

49 Laufzeit Jede Menge h(i,k) kann höchstens so viele Elemente haben, wie es Nichtterminale gibt (= konstant in der Eingabelänge). Es bleiben drei chleifen (b, i, k) über die Eingabelänge n. Deshalb terminiert KY-Algorithmus unbedingt nach O(n 3 ) chritten: polynomieller Erkenner! mal Faktor für die Größe der Grammatik (hängt aber nicht von der Eingabelänge ab)

50 Korrektheit Zu zeigen: Wenn Parser A zu h(i,k) hinzufügt, dann gilt A * w i... w k-1. Vollständige Induktion über k-i: k-i = 1: Folgt aus Regeln für Terminalsymbole. KY-Parser fügt A zu h(i,k) nur dann hinzu, wenn es Regel A und i < j < k gibt mit h(i,j) und h(j,k). Wenn Aussage also für h(i,j) und h(j,k) gilt, dann ist A * w i... w j-1 * w i... w j-1 w j... w k-1

51 Vollständigkeit Zu zeigen: Wenn A * w i... w k-1, dann legt Parser irgendwann A nach h(i,k). Knackpunkt im eweis: Zum Zeitpunkt der erechnung von h(i,k) stehen alle Einträge, die kürzer als k-i sind, schon in der hart. Das wird durch die Reihenfolge der chleifen im KY-Algorithmus garantiert. äußerste chleife geht über reite des Teilstrings innere chleifen über Anfangsposition, reite des linken Teils

52 Implementierung Idee der Datenstruktur: chart[i][k] = h(i+1, k+1) chart ist eine Liste von Zeilen der harts Jede Zeile ist eine Liste von Mengen von NT-ymbolen. Initialisierung: chart = [] for in in range(n+1): row = [] for j in range(n+1): row.append(set()) chart.append(row)

53 Implementierung for i in range(n): for prod in grammar.productions(rhs=words[i]): chart[i][i+1].add(prod.lhs()) # Terminalregeln for width in range(2, n+1): # inaere Regeln for i in range(0, n-width+1): for j in range(1, width): nts1 = chart[i][i+j] nts2 = chart[i+j][i+width] for nt1 in nts1: productions = grammar.productions(rhs=nt1) for production in productions: if production.rhs()[1] in nts2: chart[i][i+width].add(production.lhs())

54 Implementierung: Parser Für einen Parser merkt man sich zu jedem Nichtterminal in einer hartzelle, auf welche (mehreren) Weisen man es bauen kann. chart[i][k] ist jetzt Dictionary (statt Menge). keys(chart[i][k]): Nichtterminale A, die den Teilstring w i... w k-1 abdecken können Eintrag chart[i][k][ A ]: Liste von ackpointern, d.h. Tripeln (,, j), die angeben, dass A aus von i bis j plus von j bis k gebaut werden kann. Daraus mit rekursiver Funktion äume ausrechnen.

55 Zusammenfassung Rekursionsbasierte Parser (RD, R) können exponentielle Laufzeit brauchen. in der Praxis viel zu langsam KY ist polynomieller Erkenner. verwendet hart, um Zwischenergebnisse zu tabellieren. Laufzeit reduziert sich auf O(n 3 ).