INF2820 Datalingvistikk V2012 Jan Tore Lønning
LITT PYTHON 2
Hvorfor Pyhton NLTK Natural Language Tool Kit: Omgivelser for å eksperimentere med datalingvistikk Diverse datalingvistiske algoritmer Inkluderte språkdata, korpora Vekt på læring Python var først scripting language: Styre andre programmer, inkludert NLTK rutiner Gode redskaper for behandling av tekst string, list Intuitiv og lesbar syntaks som en pseudokode Read-eval-print -løkke for rask utvikling 3
Python syntaks def f(i): for j in [2,3,4]: i=j+i print i def g(i): for j in [2,3,4]: i=j+i print i Tilordning: a = 5 Python bruker indent som blokkavgrenser: Andre språk: begin-end, ( ) Hva tror du blir resultatet av kallene f(8) g(8) 4
Python datatyper integer float string: Hello world lister: [3, 4, 5] [ Hello, world ] [3, 4, c] Aksesseres med indekser mutable >>> a = "Hello world" >>> a 'Hello world' >>> len(a) 11 >>> a[0] 'H' >>> a[-1] 'd' >>> b = a[3:7] >>> b 'lo w' >>> type(b) <type 'str'> >>>c = 10 >>>e = [3,4,c,c+c,5*c] >>>e [3,4,10,20,50] >>>e[3] = 19 >>>e [3,4,10,19,50] >>>f = e[1:] >>>f [4,10,19,50] >>>e[3]=f >>>e [3,4,10,[4,10,19,50],50] >>>f[2]=0 >>>e? 5
Python er objektorientert Alt er objekter Har sine metoder Eksempler med strenger: Hello world,.split() world,.strip(, ) 6
DFA i Python if state in fa.finals: return True: else: return False def recognize(fa, streng): state = fa.start samme som while True: if len(streng)==0: return state in fa.finals elif (state,streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] streng = streng[1:] Jurafsky & Martin, fig. 2.13 Enkel Python 7
DFA i Python - datastruktur class DFA: def init (self): self.edge = {} self.finals = [] f = DFA() Denne strukturen for visning på skjerm f.start Bedre = 0 praksis (mer tekst): f.finals.append(4) Rutiner i klassen som leser inn data og f.edge[(0,'b')] konstruerer = objektet 1 Legg funksjonen som metode i klassen f.edge[(1,'a')] = 2 f.edge[(2,'a')] = 3 f.edge[(3,'a')] = 3 f.edge[(3,'!')] = 4 Datastruktur def recognize(fa, streng): state = fa.start while True: if len(streng)==0: return state in fa.finals elif (state,streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] streng = streng[1:] Enkel Python 8
Rekursjon iterasjon def recognize3(fa, streng, trace=0): state = fa.start return rec(fa, state, streng, trace) def rec(fa, state, streng, trace): if trace > 0: print streng, state if len(streng)==0: return state in fa.finals elif (state, streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] return rec(fa, state, streng[1:], trace) def recognize(fa, streng): state = fa.start while True: if len(streng)==0: return state in fa.finals elif (state,streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] streng = streng[1:] Rekursiv Iterativ 9
PROSESSERING MED NFA 10
Søkerom 11
Breddeførst søk JFLAP Parallellsøk er noe tilsvarende 12
Dybdeførst søk m/ Backtracking Jurafsky og Martin 13
Husk: rekursiv DFA def recognize3(fa, streng, trace=0): state = fa.start return rec(fa, state, streng, trace) def rec(fa, state, streng, trace): if trace > 0: print streng, state if len(streng)==0: return state in fa.finals elif (state, streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] return rec(fa, state, streng[1:], trace) def recognize(fa, streng): state = fa.start while True: if len(streng)==0: return state in fa.finals elif (state,streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] streng = streng[1:] Rekursiv Iterativ 14
NFA i Python - Backtracking def recognize3(fa, streng, trace=0): state = fa.start return rec(fa, state, streng, trace) def recognize4(fa, streng, trace=0): state = fa.start return rec(fa, state, streng, trace) def rec(fa, state, streng, trace): if trace > 0: print streng, state if len(streng)==0: return state in fa.finals elif (state, streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] return rec(fa, state, streng[1:], trace) def rec(fa, state, streng, trace): if trace > 0: print streng, state if len(streng) == 0: return state in fa.finals else: states = [e[2] for e in fa.edges if state == e[0] and streng[0] == e[1] ] for state in states: if rec(fa,state, streng[1:], trace): return True return False DFA NFA uten ε-transisjoner 15
NFA i Python - Datastruktur class NFA: def init (self): self.edges = [] self.finals = [] f = NFA( ) f.start = 0 f.finals.append(4) f.edges= [ (0,'b',1), (1,'a',2), (2,'a',3), (3,'a',3), (3,'!',4) ] g=nfafromfile('template.nfa') def recognize4(fa, streng, trace=0): state = fa.start return rec(fa, state, streng, trace) def rec(fa, state, streng, trace): if trace > 0: print streng, state if len(streng) == 0: return state in fa.finals else: states = [e[2] for e in fa.edges if state == e[0] and streng[0] == e[1] ] for state in states: if rec(fa,state, streng[1:], trace): return True return False NFA uten ε-transisjoner 16
Python: list comprehension edges = [e for e in fa.edges if state == e[0] and streng[0] == e[1] ] { e fa. edges e[0] = state e[1] streng[0] } E = = edges = [] for e in fa.edges: if state == e[0] and streng[0] ==e[1]: edges.append(e) 17
Python: list comprehension states = [e[2] for e in fa.edges if state == e[0] and streng[0] == e[1] ] states = [e[2] for e in fa.edges if state==e[0] and streng[0]==e[1] ] states = [] for e in fa.edges: if state==e[0] and streng[0]==e[1]: states.append(e[2]) S { e[2] e E} = { e[ 2] e { e fa. edges e[0] = state e[1] streng[0] } S = = 18
Jurafsky og Martins algoritme Strengt tatt: nøytral mht. Dybde-først vs bredde-først Bruker løkke+agenda i stedet for rekursjon 19
Egenskaper ved algoritmene Både dybde-først m/backtracking breddeførst vil i verste fall ha eksponentielt tidsforbruk proporsjonalt med k n, der n= w, lengden av input k 2 er maks antall kanter fra en node merket med samme symbol Med epsilontransisjoner Kan risikere ikke terminerer! Men vi vet jo at hvis vi først lager DFA får vi linjært tidsforbruk! 20
En raskere algoritme En konfigurasjon består av: En mengde tilstander Resten av strengen Start: Q0 = E({q0}) (E er epsillontillukning) Oppdatering Gitt konfigurasjon: w_n = s w Qn={q1,, qk} La ny konfigurasjon være w_n+1 = w Qn+1=E(δN(q1,s) δn(q2,s) δn(qk,s)) Akseptering Konfigurasjonen w_n = ε Qn={q1,, qk} Aksepterer hvis minst en av q1,, qk er en sluttilstand. 21
NFA-anerkjenning i Python (uten ε) def recognize(fa, streng): state = fa.start while True: if len(streng)==0: return state in fa.finals elif (state,streng[0]) not in \ fa.edge.keys(): return False else: state = fa.edge[(state,streng[0])] streng = streng[1:] def recognize5(self, streng, trace=0): states = [self.start] while True: if trace > 0: print streng, list(states) if len(streng)==0: successtates = [s for s in states if s in self.finals] return len(successtates)> 0 elif len(states) == 0: return False else: states = set([e[2] for e in self.edges if e[0] in states and streng[0] == e[1] ]) streng = streng[1:] Deterministisk Ikke-deterministisk 22
Egenskaper Svarer til underveis å bygge de delene vi trenger av DFA-ene som svarer til denne NFA-en. Algoritmen er linjær i w =n. Men kvadratisk i antall tilstander: m O(n m**2) Terminerer 23
Implementasjonon av NFA-er Oppsummering: 1. DFA-algoritmen: Konstruer en ekvivalent DFA (Minimaliser denne) Bruk DFA-en 2. NFA-algoritmen: Som simulerer DFA underveis For 1: Teoretisk raskere Mot 1: DFA-en kan få 2 n tilstander der n er tilstander i NFA-en: Tar mye plass Kan i praksis ta lengre tid å slå opp i DFA-en Hvilken algoritme som er best: Er et empirisk spørsmål Avhenger av oppgaven 24
REGULÆRE UTTRYKK I PRAKSIS 25
Regulære uttrykk to tilnærminger Teoretisk Sett på så langt Oprinnelig (1950-tallet) J&M seksj 2.3 Tilstreber: Minst mulig notasjon for å definere klassen Formelt meget veldefinert Praktisk RegEx Unix (grep/egrep), Perl, Emacs, Tilstreber effektiv i bruk Spesialsymboler, div. forkortelser. MEN: kan inneholde muligheter som går ut over de regulære språkene! 26
Forskjeller til teoretiske RE Vi beskriver ikke et språk men søker etter substrenger av et språk Ankere ^ begynnelsen av linjen $ slutten av linjen Går ut over rene RE Muligheten til å referere tilbake til hele grupper: Går utover regulære språk Kan ikke uten videre bruke DFA som algoritme 27
Implementasjon av regex 3. Backtracking: En prøver å matche regex direkte mot (et segment av) strengen Leser regex fra venstre mot høyre (tilpasset for * + ) Ser om en kan utvide strengsegmentet til å matche neste symbol i regex Hvis ikke: backtrack gå tilbake på tidligere valg SØK: finn et delsegment av strengen som matcher OBS: Regex går også utover kontekstfrie språk 28
Implementasjon av regex Hvis ekte regulært uttrykk: Gjør om til NFA Bruk algoritme 1 eller 2 Hvis regex går utover regulære uttrykk er det vanlige Bruk algoritme av type 3 29
Ta med hjem: Gitt en NFA: N som beskriver et språk L=L(N) Da finnes det en DFA: D som beskriver samme språk, L=L(D) Skal vi implementere N, kan vi enten konstruere D (forrige gang) Eller prosessere direkte med N (som om det var D) Uansett er prosedyren Ikke flertydig Deterministisk Tidsforbruket er linjært i input 30