Induktive Funktionale Logische Programmierung

Induktive Funktional-Logische Programmierung
Künstliche Intelligenz und Software-Engineering
WS 2000 / 2001
Betreuerin:
Petra Hofstedt
Verfasser:
Susanne Ressel
Dirk Mügge
Inhaltsverzeichnis
1 Einleitung ............................................................................... 3
Was ist „Logische Programmierung“? .................................................................................... 3
Was ist „Funktionale Programmierung“? ................................................................................ 3
Was ist Funktional-Logische Programmierung? ..................................................................... 3
2 Grundlagen - Logik ............................................................... 4
2.1 Logik ................................................................................................................. 4
Terme, Grundterm .................................................................................................................... 4
Variante ..................................................................................................................................... 4
Termposition , O(t) .................................................................................................................... 4
Klausel ....................................................................................................................................... 5
Literal ........................................................................................................................................ 5
Substitution ................................................................................................................................ 5
Unifikation ................................................................................................................................. 5
2.2 Logische Programmierung ............................................................................. 5
Resolution ................................................................................................................................. 5
2.3 Induktive Logische Programmierung ........................................................... 5
Beschreibung ............................................................................................................................. 5
3 Induktive Funktional-Logische Programmierung .............. 6
3.1 FLP .................................................................................................................... 6
Sinn und Zweck von Narrowing ................................................................................................ 6
Narrowing: Ein Beispiel ............................................................................................................ 6
Narrowing: Formale Definition ................................................................................................ 7
3.2 IFLP................................................................................................................... 8
Einleitung: „Inverse Narrowing“ ............................................................................................. 8
Grundlagen für „Inverse Narrowing“
Definition: Beschränkte Generalisierung (RG = Restricted Generalization) ................... 8
Definition: Konsistent Beschränkte Generalisierung (CRG = Consistent RG) .................... 8
Beispiel zur CRG: ..................................................................................................................... 8
Beschreibung „Inverses Narrowing“ ....................................................................................... 9
Beispiel zu „Inverses Narrowing“ ........................................................................................... 9
Beschreibung des IFLP-Algorithmus (Def. nach [1]) ............................................................ 10
Prozedur „GenerateCRG“ ..................................................................................................... 11
Prozedur „InverseNarrowing“ ............................................................................................... 11
IFLP-Algorithmus ................................................................................................................... 12
4 Anwendung ........................................................................... 13
Das FLIP System .................................................................................................................... 13
Index......................................................................................... 14
Literaturverzeichnis ............................................................... 15
Induktive Funktional-Logische Programmierung
Seite 2
1 Einleitung
Diese Arbeit erläutert das Prinzip der induktiven funktional-logischen
Programmierung, in deren Mittelpunkt das „Inverse Narrowing“ steht. Zu diesem
Zweck führen wir Techniken auf, die für das „Inverse Narrowing“ nötig sind.
Was ist „Logische Programmierung“?
Logische Programme bestehen aus einer Menge von Klauseln und Fakten. An diese
Programme können Anfragen gestellt werden, die mit true oder false beantwortet
werden. Bei der logischen Programmierung wird mittels der Substitution eine
Belegung der Variablen festgelegt, welche man sich auch Anzeigen lassen kann.
Was ist „Funktionale Programmierung“?
Bei der funktionalen Programmierung werden, durch Angaben von Funktionen,
Programme auf einem abstrakten mathematischen Niveau modelliert. Die Eingabe
und Ausgabe stehen in einer eindeutigen Relation zueinander.
Was ist Funktional-Logische Programmierung?
Funktional-logische Programmierung versucht die Konzepte logischer und
funktionaler Programmierung (Sprachen) zu kombinieren. Beide Sprachkonzepte
enthalten Elemente, die zur Problemlösung geeignet scheinen.
Logische Programmierung bringt partielle Datenstrukturen und funktionale
Programmierung unendliche Datenstrukturen mit sich.
Die funktionale Auswertung ist effizienter und besser zu kontrollieren, während
logische Auswertung Variablen und Inversion unterstützt.
Im Vergleich zu rein logischen Sprachen haben funktional-logische Sprachen ein
effizienteres operationales Verhalten, da Funktionen eine deterministische Auswertung
besser unterstützen als Prädikate.
Induktive Funktional-Logische Programmierung
Seite 3
2 Grundlagen - Logik
Da wir die allgemein gängigen Definitionen verwenden, verzichten wir an dieser
Stelle auf eine formale Darstellung (siehe Literaturverzeichnis).
2.1 Logik
Terme, Grundterm
Als Term werden eine oder mehrere algebraische Größen (wie Zahlen oder
Buchstabensymbole) bezeichnet, die durch Funktionssymbole (+,-,*,/, ...), sowie
durch verschiedene Arten von Klammern zur Festlegung der Operationsfolge,
verknüpft sind. Ein Grundterm ist ein Term, der keine Variablen enthält.
Variante
Eine Variante einer Regel erhält man durch Umbenennung aller Variablen.
Termposition , O(t)
Eine Position p in einem Term t wird repräsentiert durch eine Sequenz von natürlichen
Zahlen, die durch Punkte getrennt sind. t|p bezeichnet den Subterm von t an der
Position p und t[s]p bezeichnet das Resultat der Ersetzung des Subterms t|p durch s.
Darstellung der Termpositionen von 0 + s(x + s(y)) = s(x) + s(y)
Mit O(t) bezeichnet man die Menge aller Termpositionen von Term t.
Induktive Funktional-Logische Programmierung
Seite 4
Klausel
Eine Klausel ist eine Menge von Literalen.
Literal
Sei P eine Menge von Aussagensymbolen.
Eine Formel ψ ∈ Form(P) heißt Literal, wenn entweder ψ
p P.
P oder ψ = ~p mit
Substitution
Eine Substitution ist eine endliche Menge von Einsetzungen von Termen ti für Variable
vi in einer Formel.
Unifikation
Eine Substitution heißt Unifikator, wenn sie eine Menge von Ausdrücken egalisiert.
Wenn ein Unifikator existiert, dann existiert auch ein allgemeinster Unifikator.
Ein allgemeinster Unifikator ist ein Unifikator, der durch Substitution in jeden anderen
Unifikator überführt werden kann.
2.2 Logische Programmierung
Resolution
Die Resolutionsmethode ist ein effektives Verfahren zur Konstruktion von Beweisen.
Bei der Resolutionsmethode wird die Negation der Behauptung zu den Axiomen
(Behauptung und Axiome liegen in definiten Klauseln vor) hinzugefügt und eine
Widerlegung, d. h. Herbeiführung eines Widerspruches, versucht.
2.3 Induktive Logische Programmierung
Beschreibung
ILP ist ein Zusammenschluß aus induktivem Lernen und logischer Programmierung.
Das Hauptziel ist die Entwicklung von Hilfsmitteln, Theorien und Techniken zum
Erzeugen von Hypothesen aus Beispielen und Hintergrundwissen. Dies wird unter
anderem durch die inverse Resolution erreicht, welche auf die Resolution zurückgeht.
Induktive Funktional-Logische Programmierung
Seite 5
3 Induktive Funktional-Logische Programmierung
Wir betrachten kurz die funktional-logische Programmierung und führen das
Narrowing, als Vorbereitung auf IFLP, ein.
3.1 FLP
Sinn und Zweck von Narrowing
Bei der Ausführung eines Programms kann es zur Auswertung eines funktionalen
Ausdrucks kommen, der uninstanziierte Variablen enthält. Dies ist ein grundlegendes
Problem bei der Integration von funktionaler und logischer Programmierung.
Narrowing löst das Problem durch fundierte Annahmen über die Werte dieser
Variablen, um eine nahtlose Integration von logischen und funktionalen Berechnungen
zu gewährleisten.
Narrowing: Ein Beispiel
Wir definieren uns ein Programm, welches die gewöhnliche Addition und „größer“
Relation auf den Natürlichen Zahlen definiert.
1. Regel: 0 + x = x
2. Regel: succ(x) + y = succ(x + y)
3. Regel: 0 > z = False
4. Regel: succ( z ) > 0 = True
5. Regel: succ(x) > succ(y) = x > y
Die Auswertung der Gleichung succ(0) + succ(0) > succ(0) zu True kann durch
folgende Schritte realisiert werden:
1. Schritt: succ(0) + succ(0) > succ(0) // Anwendung von Regel 2
2. Schritt: succ(0 + succ(0)) > succ(0) // Anwendung von Regel 1
3. Schritt: succ(succ(0)) > succ(0)
// Anwendung von Regel 5
4. Schritt: succ(0) > 0
// Anwendung von Regel 4
5. Schritt: True
Dieses Vorgehen nennt sich ‘Rewriting’und ist ein Modell für funktionale Auswertung.
Enthält die Auswertung einer Aussage Variablen, z. B. succ(0) > 0 + u, dann müssen
Variablen instanziiert werden (Anwendung von Unifikation), um ‘Rewriting’ zu
zulassen. Dies nennt man dann Narrowing.
Auswertung des Beispiels succ(0) > 0 + u:
1. Schritt: succ(0) > 0 + u
// Anwendung von Regel 1
2. Schritt: succ(0) > u
// Anwendung von Regel 4, {u/0}
3. Schritt: True
Das Ergebnis ist das Paar (True, {u/0}).
Induktive Funktional-Logische Programmierung
Seite 6
Die Substitution von 0 für u ist die berechnete Antwort, d.h.:
succ(0) > 0 + 0 gilt.
Eine andere Auswertung ist möglich mit Regel 5 anstatt Regel 4:
2. Schritt: succ(0) > u
// Anwendung von Regel 5, {u/succ(v)}
3. Schritt: 0 > v
// Anwendung von Regel 3
4. Schritt: False
Das Ergebnis ist das Paar (False, {u/succ(v)}).
Das bedeutet:
succ(0) > 0 + succ(v) gilt für kein v.
Im Allgemeinen kann man beliebig viele Lösungen berechnen.
Narrowing: Formale Definition
In einem ‘Narrowing’-Schritt wird ein nicht variabler Subterm von t mit der linken
Seite einer Regel unifiziert. Der so instanziierte Subterm wird dann durch die
instanziierte rechte Seite der Regel ersetzt.
Formal kann ein Term t durch ‘Narrowing’ in einen Term t’ überführt werden, wenn:
1.
p ist eine nicht variable Position in t
2.
l = r ist eine neue Variante einer Regel
3.
Die Substitution σ ist ein allgemeinster Unifikator von t|p und l.
4.
t’ = σ(t[r]p)
Beispiel: (Siehe Narrowing-Beispiel; 1.Schritt der Auswertung mit Variable.)
Sei t: succ(0) > 0 + u
p=2
(also: t|p = 0 + u)
(Variante von Regel 1)
σ=(x’/u)
t’ = σ(t[x’]2)= succ(0) > u
Somit wird succ(0) > 0 + u ersetzt durch succ(0) >u .
Induktive Funktional-Logische Programmierung
Seite 7
3.2 IFLP
Wir führen nun das „Inverse Narrowing“ ein und erklären den IFLP Algorithmus zur
Findung einer Programmerweiterung.
Als Analogie läßt sich feststellen:
Resolution für LP
Inverse Resolution für ILP
Narrowing bei FLP
Inverses Narrowing für IFLP
Einleitung: „Inverse Narrowing“
Gegeben ist eine Menge von positiven Beispielen E+ und negativen Beispielen Eund ein Programm B, sog. Basiswissen.
Gesucht ist ein Programm P, so dass
BUP
alle Beispiele aus E+ erfüllt und kein Beispiel aus E-.
Grundlagen für „Inverse Narrowing“
Definition: Beschränkte Generalisierung (RG = Restricted Generalization)
e’ ist eine beschränkte Generalisierung einer Gleichung e, wenn eine Substitution
existiert, die e’ auf e abbildet und die Menge der Variablen der rechten Seite von e’
eine Teilmenge der Variablen auf der linken Seite darstellt.
Definition: Konsistent Beschränkte Generalisierung (CRG = Consistent RG)
bzgl. E+, E- und B U P
CRG entspricht e = {l1 = r1}
gdw.
1.
e ist RG für mind. ein
,
2.
es existiert keine ‘Narrowing’-Kette, die e benutzt und die ein
liefert.
Es darf keine linke Seite eines Elementes aus E- abgeleitet werden, so daß die
rechte Seite als Ergebnis hergeleitet wird, und
3.
es existiert keine ‘Narrowing’-Kette, so dass
l’ ~~>e ... ~~> r’’ != r’
mit
Beispiel zur CRG:
Wir wollen Regeln für die Addition ableiten.
Gegeben ist ein positives und negatives Beispiel und Basiswissen.
E+: 0 + s(0) = s(0)
E-: 0 + s(0) = 0
B:
s(x) + y = s(x+y)
zu 1.
Erzeugung einer RG, durch Ersetzen einer Konstanten durch eine Variable.
σ = {x/0}
=> e = {x + s(x) = s(x)}
Induktive Funktional-Logische Programmierung
Seite 8
zu 2.
Mit der RG dürfen die negativen Beispiele nicht hergeleitet werden können.
0 + s(0) ~~> s(0) ~/~> 0
Es gibt keine Narrowing-Kette um 0 + s(0) zu 0 abzuleiten.
zu 3.
Es darf keine ‘Narrowing’-Kette geben, so daß eine andere rechte Seite
abgeleitet wird, als r’.
0 + s(0) ~~>e s(0)
Es ist nicht möglich, mit einer Gleichung aus B, eine Ableitung zu realisieren,
die eine andere Normalform erzeugt.
Beschreibung „Inverses Narrowing“
Sei P ein Programm. t, t’ sind Terme
t’ kann durch inverses Narrowing von t gebildet werden, wir schreiben
t’
t
gdw.
u ∈ O(t), { l = r } P
θ = mgu(t|u,r)
und t’ = θ(t[l]u)
Vorgehensweise für IFLP:
und { l = r }
Sei { s = t } E+
Existiert
θ = mgu(t|u,r) ,
dann erhält man neue Regeln wie folgt:
s = θ(t[l]u) mit l = r
B
Beachte, dass für jede Termposition ein θ gebildet werden kann. Damit können
ebenso viele neue Gleichungen gebildet werden, wie Anzahl θ’s.
Beispiel zu „Inverses Narrowing“
Sei B unser betrachtetes Programm.
e’ = { X’ + 0 = X’ }
B
// Eine Gleichung des Basiswissens B
l = X’ + 0
// linke Seite von e’
r = X’
// rechte Seite von e’
{l=r} B
(1)
Sei e ein positives Beispiel für unser zu konstruierendes Programm P.
e E+:
e = { X + s(0) = s(X) }
// Gleichung des positiven Beispiels
u = X + s(0)
// linke Seite des Beispiels
t = s(X)
// rechte Seite des Beispiels
u=t
//Die mit dem erweiterten Programm zu erfüllende Gleichung
Induktive Funktional-Logische Programmierung
Seite 9
Bildung des allgemeinsten Unifikators θ:
θε = {X’ / s(X)}
σ =mgu(t|u,r)
θ1 = {X’/X}
t’ε = s(X) + 0 = σ(t[l]u)
t’1 = s(X + 0)
=>
(Term t wird durch r ersetzt)
(X wird durch r ersetzt)
X + s(0) = s(X) + 0
(2)
X + s(0) = s(X+0)
(3)
Diese beiden Gleichungen werden dem Programm P hinzugefügt.
Wir haben so ein neues Programm erhalten:
X’ + 0 = X’
X + s(0) = s(X) + 0
X + s(0) = s(X+0)
Probe, d.h. wir wollen zeigen, dass e E+ ableitbar ist:
X’’ + s(0) ~~> ((2) mit σ{X’’/X}) s(X’’) + 0
~~> ( (1)mit σ’{s(X’’)/X’}) s(X’’)
=> u = t
X’’ + s(0) ~~> ( (3) mit σ{X’’/X}) s(X’’+ 0) ~~>( (1)mit σ’{X’’/X}) s(X’’)
=> u = t
Beschreibung des IFLP-Algorithmus (Def. nach [1])
Wir starten den induktiven Prozeß mit den positiven und negativen Beispielen E+
und E-. Zusätzlich kann Hintergrundtheorie (B) benutzt werden um das Zielprogramm
P zu induzieren. Bezeichne BF die Basisfunktionen.
Der IFLP Algorithmus hat drei Parameter.
1)
min stellt die maximale Anzahl von CRG’s dar, die in einem Schritt des
Algorithmus generiert werden müssen.
2)
step der Wert, um den min erhöht wird (falls keine Lösung gefunden
werden kann)
3)
inarcomb maximale Anzahl von „inverse Narrowing“ Schritten, die mit
einem Paar von Programmen durchgeführt werden kann.
Die Parameter sollen die Performance und Effektivität des Algorithmus verbessern.
Der Standard IFLP Algorithmus lernt Programme, indem er zwei Gruppen von
Hypothesen generiert:
- Menge von Gleichungen (EH), die hauptsächlich durch CRG generiert wurden
- Menge von Programmen (PH), die ausschließlich aus Gleichungen EH entstanden
In jedem Schritt des Algorithmus entstehen neue Gleichungen und Programme durch
das „inverse Narrowing“.
Der Algorithmus läßt sich über zwei Hilfsprozeduren aufbauen:
GenerateCRG(input: E+, E-, EH, min; output: EHf)
InverseNarrowing(input: P1, P2, BF, inarcomb; output: EH, PH)
Induktive Funktional-Logische Programmierung
Seite 10
Prozedur „GenerateCRG“
Gibt eine Menge EHf zurück, indem man eine Menge von Gleichungen, die CRG’s
für E+ und E- sind und aus jedem Beispiel aus E+ konstruiert wurden, zu EH hinzufügt.
Die Größe von EHf ist durch min beschränkt.
Prozedur „InverseNarrowing“
Gibt eine Menge von Gleichungen und Programmen zurück, die man wie folgt erhält:
Als erstes wird „inverses Narrowing“ auf Gleichungen aus den beiden eingegebenen
Programmen angewendet (bis zu inarcomb Kombinationen) und dann werden die
Mengen verkleinert um Redundanzen und Inkonsistenzen zu eliminieren.
Eingabe: P1, P2, BF, inarcomb
Berechne eine Menge von Gleichungen E, indem „inverse Narrowing“-Schritte
auf die „beste“1 Gleichung aus P1 und alle Gleichungen aus P2
angewendet werden.
Wir berechnen alle CRG’s C für alle Elemente aus E.
Sei die Menge der Gleichungshypothesen (EH) die Vereinigung über C.
Sei die Menge der Programmhypothesen (PH) die Vereinigung über C,P1
und P2 ohne die „beste“ Gleichung aus P1.
Berechne alle „coverings“2 und „optimalities“3 jedes Elementes von der
Potenzmenge von PH.
Solange ein Programm p in PH existiert, welches inkonsistent und
nicht „confluent“ ist, wiederhole:
Falls p nicht konsistent ist, dann entferne p aus PH
Falls p nicht „confluent“ ist, ersetze p durch alle seine „confluenten“
Teilmengen.
Ende Schleife
Entferne alle redundanten Gleichungen aus Elementen von PH.
Ausgabe: EH, PH
1
Im Sinne eines definierten Optimalitätskriteriums.
Macht eine Aussage über die Anzahl der abgedeckten positiven Beispiele einer Gleichung.
3
Optimalitätsfunktion, die Parameter enthält, die auf verschiedene Probleme angepasst werden können.
2
Induktive Funktional-Logische Programmierung
Seite 11
IFLP-Algorithmus
Eingabe: pos. u. neg. Beispiele, Basiswissen, Parameter
Generiere CRG’s
Solange „Stop Kriterium“4 nicht erfüllt wiederhole
Existiert keine Programmhypothese, die ein Optimalitätskriterium erfüllt
dann:
Wähle eine Teilmenge der pos. Beispiele E
Für jedes Element e aus E wiederhole:
Sei e ein Programm P.
Führe aus:
InverseNarrowing für P, Basiswissen und
Teilmenge des Basiswissens (BF)
Neue und alte Prorgammhypothesen vereinigen.
Neue und alte Gleichungshypothesen (CRG’s) vereinigen.
Bestes Programm bestimmen.
Ende Schleife
Sei: n = #pos. Beispiele
Solange n > 0 wiederhole
Sei PP die Menge aller Prorgammpaare für die gilt:
P1,P2 sind aus der Menge der Programmhypothesen und
ungleich und die Anzahl pos. Beispiele, die von P1 oder
P2 erfüllt werden ist größer als n
Falls PP nicht leer ist,
dann:
Wähle das Programmpaar P1,P2, so dass die Summe der
Optimalitätskriterien maximal wird.
Beende Schleife.
sonst:
Verringere n um 1.
Ende Schleife
Falls n=0,
dann:
Erhöhe Anzahl zu generierender CRG’s
Generiere CRG’s
Wenn alte und neue Gleichungshypothesen identisch sind,
dann:
Abbruch, es gibt keine neuen Programmhypothesen
=> Keine Lösung.
sonst:
InverseNarrowing für P, Basiswissen und BF
Neue und alte Prorgammhypothesen vereinigen.
Neue und alte Gleichungshypothesen (CRG’s) vereinigen.
Bestes Programm bestimmen.
Ende Schleife
Ausgabe: „Bestes Programm“
4
Man wählt i.d.R. eine Kombination aus diversen Optimalitätskriterien.
Induktive Funktional-Logische Programmierung
Seite 12
4 Anwendung
Das FLIP System
Das „Functional Logic Inductive Programming System“ ist in der Lage, aus positiven
und negativen Beispielen sowie unter Verwendung von Basiswissen,
Programmhypothesen zu erzeugen.
Es hat sich gezeigt, dass die Wahl der Beispiele besonders wichtig ist.
Induktive Funktional-Logische Programmierung
Seite 13
Index
B
Beschränkte Generalisierung 8
konsistente 8
Beispiel 8
F
Funktionale Programmierung 3
I
Inverse Narrowing
Algorithmus 10
Grundlagen 8
Prozedur
GenerateCRG 11
InverseNarrowing 11
Vorgehen 8
K
Klausel 5
L
Literal 5
Logische Programmierung 3
N
Narrowing 6. Siehe auch Inverse Narrowing
Beispiel 6–7
Grundlagen 6
R
Resolution
Methode 5
S
Substitution 5
T
Terme 4
Termposition 4
U
Unifikation 5. Siehe Substitution
Unifikator
allgemeinster 5
V
Variante 4
Induktive Funktional-Logische Programmierung
Seite 14
Literaturverzeichnis
[1] J. Hernandez-Orallo, M.J. Ramirez-Quitana. Inverse Narrowing for the Induction of Funtional Logic.
Website http://www.dsic.upv.es.
[2] Peter A. Flash. The logic of learning: a brief introduction to Inductive Logic Programming.
Website http://www.cs.bris.ac.uk/~flach, 1998.
[3] M. Hanus. The Integration of Functions into Logic Programming: From Theory to Practice.
In: Journal of Logic Programming. Vol.19&20. 1994. S.583-628.
[4] Katharina Morik. Maschinelles Lernen.
Skriptzur Vorlesung. 1999.
[5] Ehrig, Mahr, Cornelius, Große-Rhode, Zeitz. Grundlagen der Informatik.
Springer-Verlag, Berlin. 1998
[6] C. Ferri-Ramirez, J. Hernandez-Orallo, Ramirez-Quitana, M. José. The FLIP System.
Website http://www.dsic.upv.es/~jorallo/flip/. 2000.
[7] Sergio Antony. Research in Functional Logic Programming at Portland State
Website http://www.cs.pdx.edu/~antoy. 2000.
Induktive Funktional-Logische Programmierung
Seite 15