KI- automatische Sprachverarbeitung Einführung mit Scheme

KI- automatische Sprachverarbeitung Einführung mit Scheme -
Tests
KI- automatische Sprachverarbeitung Einführung mit Scheme -
Tests
Test B (zum Einschub von Scheme und Teil 2)
1. Folgendes Lexikon sei gegeben.
(define *lex*
'((cat gato katze)
(dog perro hund)
(eats come frisst)
(jumps salte springt)
(the el die)
(the la der)))
Gib an, wie man `(el gato salte) herausfiltern kann. (Erst el, dann gato, dann salte, also drei
verschiedenen Funktionen).
(define (el liste) (car(cdr (car (cdr (cdr (cdr (cdr *lex*))))))))
(define (gato liste) (car (cdr (car *lex*))))
(define (salte liste) (car (cdr (car (cdr (cdr (cdr *lex*)))))))
2. Definiere folgende Funktionen als Scheme Funktionen (schreibe für jede Funktion eine
eigene Definition in der Form (define (f…..)):
a. f(x) =
b. g(x,y) =(2x – 3y):2
a. (define (f x)) (+(*(pot (x)) ½ )3)
b. (define (g x)) (:(-(2 x) (3 y)) 2)
3. Erläutere den Unterscheid zwischen folgenden Listen:
a. `(a b c def)
b. (a b c def)
a) ist eine Datenliste und b) ist eine Liste mit Argumenten zu Funktionen (Operatoren).
KI- automatische Sprachverarbeitung Einführung mit Scheme -
Tests
Test C (Teil 3)
1. Was bedeutet Rekursion? (Gib die Hauptmerkmale einer rekursiven Funktion an)
2. Beschreibe zu folgenden Funktionen eine funktionale Modellierung in formalisierter
Umgangsprache. Implementiere die im Folgenden gegebenen rekursiven Funktionen und
zeichne anschließend einen entsprechenden Rekursionsbaum dazu
a.
(enthalten? wort liste): eine Funktion, die #t zurückliefert, wenn das Wort in der
Liste liste enthalten ist, sonst #f.
b. Fakultät von n: n! . Es gibt folgende rekursive Definition von Fakultät: n! = n·(n-1)!
c. (suchen? element liste1 liste2): eine Funktion, die #t ausgibt, wenn „element“ in
beiden Listen vorkommt, sonst #f.
3. Was tut folgende Funktion?
(define (suchen? liste1 liste2)
(cond ((null? liste1) #f)
((null? liste2) #f)
((equal? (car liste1) (car liste2)) #t)
(else (suchen (cdr liste1) (cdr liste2)))))
Ein Aufruf könnte folgendermaßen aussehen: (suchen? `(a b c d e) `(x y z d k)) .
4. Zeichne einen Rekursionsbaum, der den Ablauf von „suchen?“ darstellt.
KI- automatische Sprachverarbeitung Einführung mit Scheme -
Tests
Test D (Teil 4)
1. Folgendes Lexikon sei gegeben:
(define *lex*
'((cat gato katze)
(dog perro hund)
(eats come frisst)
(jumps salte springt)
(the el die)))
Folgende Funktion (wortuebersetzung wort lexikon sprache) soll implementiert werden.
Formuliere zunächst einen Algorithmus in formalisierter Umgangssprache, der
a. eine Wortübersetzung eines Wortes „wort“ ins Englische oder Spanische ermöglicht
b. eine Satzübersetzung eines Satzes „satz“ ins Englische oder Spanische ermöglicht
Implementiere nun folgende Funktionen:
a. (wortuebersetzung wort lexikon sprache)
b. (satzuebersetzung satz lexikon sprache)
Folgende Beispielaufrufe sollen verdeutlichen, wie die Funktionen arbeiten sollen:
a. (wortuebersetzung `katze *lex* `ènglisch) -> cat
b. (satzuebersetzung `(die Katze frisst) *lex* `spanisch) -> `(el gato come)
2. (Zusatz – schwieriger) Folgendes Lexikon sei gegeben:
(define *lex*
'((cat katze w)
(dog hund m)
(eats frisst)
(jumps springt)
(the (der die das))))
Folgende Funktion (satzuebersetzung satz lexikon) soll implementiert werden:
„In der Satzübersetzung soll bei jedem Nomen der richtige Artikel ausgewählt werden,
anstatt (der die das) zu schreiben. Die Entscheidung, welcher Artikel zu wählen ist, fällt durch
die zusätzliche Angabe von m, w oder s bei jedem Nomen (wie im Lexikon bereits eingefügt).
Bsp.: `(the dog jumps) -> `(der Hund springt)“.
Zusatz zum Zusatz: Eine zusätzliche Schwierigkeit würde sich ergeben, wenn man auch
Adjektive zulässt. Also z.B. auch Sätze der Art `(the nice cat jumps).“
KI- automatische Sprachverarbeitung Einführung mit Scheme -
Tests
Test E (Teil 6 und 7)
1. Stelle einen Parsebaum auf zu folgendem Satz `(the dog runs after the cat). Verwende
dazu folgende Grammatik:
S
--> NP VP
VP
--> V NP
ART
--> the
NP
--> N
VP
--> VP PP
V
--> eats
NP
--> ART N
PP
--> P NP
V
--> runs
VP
--> V
N
--> cat
P
-->after
N
--> dog
a. Stelle einen Parsebaum entsprechend einer Tiefensuche auf.
2. Folgender Parser sei gegeben:
(define (start eingabe)
(let ((startkeller (list 'np 'vp)))
(parse eingabe startkeller)))
(define (parse eingabe keller)
(cond ((and (null? eingabe) (null? keller)) #t)
((null? keller) #f)
((null? eingabe) #f)
((equal? (car keller) 'vp) (vp-fkt eingabe (cdr keller)))
((equal? (car keller) 'np) (np-fkt eingabe (cdr keller)))
((equal? (car keller) 'n) (n-fkt eingabe (cdr keller)))
((equal? (car keller) 'v) (v-fkt eingabe (cdr keller)))
((equal? (car keller) 'art) (art-fkt eingabe (cdr keller)))
((equal? (car eingabe)(car keller)) (parse (cdr eingabe)(cdr keller)))
(else #f)))
(define (vp-fkt eingabe keller)
(or (parse eingabe (cons 'v keller))
(parse eingabe (append (list 'v 'np) keller))))
(define (np-fkt eingabe keller)
(or (parse eingabe (cons 'n keller))
(parse eingabe (append (list 'art 'n) keller))))
(define (n-fkt eingabe keller)
(or (parse eingabe (cons 'cat keller))
KI- automatische Sprachverarbeitung Einführung mit Scheme -
Tests
(parse eingabe (cons 'fish keller))
(parse eingabe (cons 'mouse keller))))
(define (art-fkt eingabe keller)
(parse eingabe (cons 'the keller)))
(define (v-fkt eingabe keller)
(or (parse eingabe (cons 'runs keller))
(parse eingabe (cons 'sits keller))
(parse eingabe (cons 'jumps keller))))
a. Stelle die zu dem Parser passenden Grammatikregeln auf.
b. Erläutere im Detail die Arbeitsweise des Parsers.
c. Erweitere den Parser um folgende Regeln:
1. VP --> VP PP
2. PP --> P NP
3. P --> in
4. P --> at
5. P --> on
3. Zusatz (schwieriger):
Schreibe den obigen Parser so um, dass er mit einer Breitensuche arbeitet.