Seminararbeit: Programmierung von Expertensystemen am Beispiel

Seminararbeit:
Programmierung von Expertensystemen am
Beispiel von CLIPS
Arbeitsgruppe 4
Lösung von Allokationsproblemen mit wissensbasierten
Verfahren
betreut durch Dipl. Kfm. Tim Stockheim
Dirk Weil
Seminar: Automatisierte Ressourcenallokation
unter der Leitung von Prof. Dr. König
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
Programmierung von Expertensystemen am Beispiel von CLIPS
Inhaltsverzeichnis
1
2
3
4
5
6
Einführung ................................................................................................................................... 3
Kurzvorstellung Expertensystem................................................................................................. 4
2.1
Einführung Knowledge Source ............................................................................................ 4
Tools zur Erstellung eines Expertensystems .............................................................................. 6
3.1
CLIPS................................................................................................................................... 6
3.2
JAVA Expert System Shell (JESS) ...................................................................................... 8
3.3
JessTab................................................................................................................................ 9
Programmbeispiel: Produktionsplanungssystem...................................................................... 10
Fazit........................................................................................................................................... 14
Literaturliste............................................................................................................................... 15
2
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
1 Einführung
Expertensysteme galten bis ca. Mitte der 90er Jahre als erfolgversprechender Ansatz der
künstlichen Intelligenz um Probleme zu lösen, bei denen Informationen nur unvollständig
bzw. unsortiert vorlagen. Einen Spezialfall dieser Expertensysteme stellt das im
Folgenden behandelte „hierarchische Blackboard System“ dar. Dieses stellt eine der
Vorstufen zu den heutigen Agentensystemen dar, da bereits diese Blackboardsysteme mit
Einheiten arbeiteten, die heutigen Agenten sehr ähneln, den sogenannten „Knowledge
Sources“.
In der vorliegenden Arbeit soll darauf eingegangen werden, welche Eigenschaften
Knowledge Sources haben sollen, wie die Entscheidungsfindung und –begründung (das
sogenannte „Reasoning“) funktioniert, und wie diese erstellt werden können.
Nach einer Erläuterung der allgemeinen Eigenschaften der Knowledge Sources werden
zwei Tools zur Erstellung von Expertensystemen vorgestellt, zum einen CLIPS und zum
anderen JESS (Java Expert System Shell), eine Programmierumgebung, die mit den
gleichen Befehlen und ebenso mit der Syntax von CLIPS arbeitet, aber dank der
Umsetzung in Java nahezu plattformunabhängig eingesetzt werden kann.
Dies erlaubt es, JESS mit anderen JAVA – basierten Tools zu ergänzen, bzw. mittels
JAVA Schnittstellen zu anderen Tools zu schaffen.
Im Anschluss daran wird noch ein Tool zur Ergänzung von JESS vorgestellt, das genau
diese Erweiterungsfähigkeit des JESS – Systems ausnutzt.
Zum Abschluss dieser Arbeit folgt dann ein Programmbeispiel für ein kleines
Expertensystem zur Produktionsplanung.
3
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
2 Kurzvorstellung Expertensystem
Expertensysteme
dienen
als
Entscheidungsbasis
für
komplexe
Probleme,
die
vielschichtige Strukturen haben und häufig von menschlichen, hochspezialisierten
Experten gelöst werden. Die Beispiele für ihre konkrete Anwendung sind äußerst
vielseitig, die Spannbreite reicht hier von Spracherkennungssystemen über medizinische
Anwendungen bis hin zu Prozesssteuerung und Produktionsplanungssystemen bei denen
es auf eine optimierte Ressourcenallokation ankommt.
Bei den hier betrachteten Blackboardsystemen handelt es sich um einen Spezialfall eines
Expertensystems. Kennzeichnend ist hier, dass versucht wurde, eine menschliche
Expertenrunde
abzubilden,
die
ihre
jeweiligen
Kenntnisse
auf
einer
Tafel
zusammenbringt, diese in Zwischenschritten zu Arbeitsergebnissen formt und zur
weiteren Verwendung durch andere Experten wieder an der Tafel anschreibt, bis ein
gemeinsames Ergebnis gefunden wurde.
Ein Blackboardsystem besteht im wesentlichen aus 3 Elementen: Dem eigentlichen
Blackboard, welches in der Regel aus einer Datenbank besteht, den „Experten“, die hier
als Knowledge Sources bezeichnet werden, sowie einer Verwaltungsinstanz, die
bestimmt, wer wann auf das Blackboard zugreifen darf, so dass Zugriffskonflikte
vermieden werden.
Es findet also eine Modularisierung von Expertise statt, die um beliebige weitere Module
(analog weiterer Experten) ergänzt werden kann. Dies verleiht den Expertensystemen
eine hohe Flexibilität, die zumindest theoretisch eine einfach zu realisierende Optimierung
des Systems erlaubt.
2.1 Einführung Knowledge Source
Kennzeichnend für die Struktur von Blackboardsystemen ist die Entscheidungsfindung
über sogenannte „Knowledge Sources“. Diese repräsentieren „Experten“, d.h. jede von
ihnen verfügt über spezielle Eigenschaften, die verschiedene Aspekte zur Problemlösung
einbringen. Knowledge Sources können:
•
Selbständig Informationen auf dem Blackboard finden und filtern
•
Anstelle eines Benutzers Aktionen selbständig durchführen
•
Im Bedarfsfall mit dem Benutzer kommunizieren um weitere Informationen zu
erhalten, oder den Benutzer über die Resultate ihrer Aktion informieren.
4
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
Daniel
D.
Corkill,
Blackboardsysteme,
einer
der
beschreibt
führenden
die
Wissenschaftler
Eigenschaften
von
auf
dem
Gebiet
Knowledge
der
Sources
folgendermaßen1:
•
Jede Knowledge Source (nachfolgend auch „KS“ genannt) ist ein Spezialist zur
Lösung bestimmter Aspekte des Gesamtproblems.
•
Keine KS erfordert andere Knowledge Sources um ihren Beitrag erbringen zu können.
Sobald sie für sie relevante Informationen auf dem Blackboard findet, kommt sie ohne
weitere Unterstützung durch andere KS aus.
•
Weitere Knowledge Sources können in das Gesamtsystem eingebracht werden, ohne
das andere KS geändert werden müssen.
•
KS die sich als wenig effizient erweisen, können ohne Auswirkungen auf die anderen
KS verändert oder aus dem System entfernt werden.
•
KS
führen
relativ
aufwendige
Berechnungen
durch,
verglichen
mit
dem
Rechenaufwand der mit ihrer Implementierung verbunden ist.
Aus dem letzten Punkt ergibt sich ein gewisser Optimierungsbedarf für die KS. Zu Zeiten,
als Rechenkapazität knapp war, wurde versucht, das Problem durch eine Abschätzung
des Ergebnisses anstelle seiner exakten Berechnung zu umgehen. In diesem Falle gibt
die
KS
den
Näherungswert,
den
potentiellen
Lösungsweg
sowie
einen
Wahrscheinlichkeitswert an die Kontrollinstanz des Blackboards weiter. Mit Hilfe dieses
Wahrscheinlichkeitswertes wird bei konkurrierenden Zugriffen auf das Blackboard
entschieden, ob das Ergebnis am Blackboard „angeschrieben“ wird, oder ob es mit einem
anderen Ergebnis verschmolzen oder gar entfernt wird, so dass es möglicherweise
niemals am Blackboard ankommt.
Ein weiteres Charakteristikum der Knowledge Sources ist die Vielzahl an Möglichkeiten
zur Umsetzung. Die Entscheidungsfindung / -begründung (auch Reasoning) kann im
einfachsten Fall eine regelbasierte Lösung sein, es kann sich dabei aber auch um so ein
neuronales Netz oder auch ein sogenanntes „Fuzzy – Logic“ Programm handeln, was
zum Beispiel vom FuzzyJ – Toolkit des National Research Center of Canada (NRC) als
Erweiterung zu JESS unterstützt wird.
1 Aus Daniel D. Corkill: Blackboard Systems, Seite 2
5
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
3 Tools zur Erstellung eines Expertensystems
Erste Tools zur Erstellung eines Expertensystems wurden ab 1977 entwickelt, hier ist vor
allem Penny Nii’s AGE Skeletal Blackboard Framework zu nennen, dass zwischen 1977
und 1982 an der Stanford Universität entwickelt wurde.
Weitere bekannte Tools waren das BB1 von Barbara Hayes-Roth (ebenfalls Stanford
Universität) sowie das UMass GBB framework von Daniel D. Corkill (University of
Massachusetts).2
Im
Folgenden
werden
zwei
Entwicklungstools
beschrieben,
die
den
letzten
Entwicklungsstand repräsentieren; CLIPS und JESS.
3.1 CLIPS
Bei CLIPS handelt es sich um eine ursprünglich von der NASA entwickelte
Entwicklungsumgebung für Expertensysteme. Es ist frei verfügbar für Solaris, Mac OS
und Windows. Obwohl CLIPS in C geschrieben wurde, ist die Syntax an LISP angelehnt,
eine Programmiersprache, die im Bereich der künstlichen Intelligenz als Referenz gilt.
Programmiert wird CLIPS in der Sprache COOL (CLIPS Object Oriented Language). Es
besteht die Möglichkeit, nach dem Start des Systems direkt Fakten und Regeln
einzugeben, mit denen das System arbeiten soll. Alternativ besteht auch die Möglichkeit,
mittels des “(batch)“ – Kommandos Dateien mit COOL – Befehlen einzulesen, die in
einem beliebigen Editor erstellt und im Textformat abgespeichert wurden.
Ein COOL – Programm besteht im Wesentlichen aus zwei Teilen: den Fakten (auch Fact
Knowledge Base) und den Regeln. Diese können jedoch in separaten Dateien enthalten
sein und nacheinander geladen werden.
Bevor das Expertensystem dann gestartet werden kann, müssen die Fakten noch aus der
Knowledge Base in den Arbeitsspeicher übertragen werden, dies geschieht mit dem
„(reset)“
–
Kommando,
welches
gleichzeitig
alte
Fakten
aus
vorhergehenden
Programmläufen aus dem Arbeitsspeicher entfernt.
Erst dann kann mittels des „(run)“ – Kommandos das Expertensystem gestartet werden.
Das System arbeitet solange Fakten vorhanden sind, die auf die bestehenden Regeln
anwendbar sind und damit die mit den Regeln verbundenen Aktionen auslösen. Diese
Aktionen können zum Beispiel auch Fakten ändern, löschen oder neu hinzufügen. (Dies
2 Aus: Daniel D. Corkill, Blackboard Systems, Seite 11
6
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
könnte z. B. die Menge eines Rohstoffs oder der erstellten Produkte in einem
Produktionsplanungssystem sein).
Mittels des „(agenda)“ – Befehls ist eine Anzeige der derzeit aktivierten Regeln möglich.
Die mit diesen Regeln verbundenen Aktionen werden in der Reihenfolge der Ausgabe
ausgeführt. Interessanterweise unterstützen sowohl CLIPS als auch JESS nur das LIFO
und das FIFO – Verfahren zur Kontrolle des Zugriffs auf das Blackboard. Offensichtlich ist
eine effektive Kontrollinstanz, wie unter 2. beschrieben, nur schwer umzusetzen.
Es ist schwer zu sagen, welcher Ansatz der effektivere ist, Maarten Menken schreibt
hierzu3:
„Es ist schwer zu beurteilen, das die eine [Methode] besser ist als die andere, ohne die
spezifische Anwendung zu betrachten. Sogar dann, kann es schwer sein, zu beurteilen,
welche die Beste ist.“
Standardmäßig benutzen CLIPS und auch JESS die LIFO – Einstellung.
Eine Regel besteht aus zwei Seiten, der „Left-Hand-Side“ (LHS) und der „Right-HandSide“ (RHS), die durch „=>“ getrennt sind.
Erstere gibt die zu erfüllende Bedingung an, auf der „Right-Hand-Side“ befindet sich die
Anweisung für den Fall, das die LHS erfüllt wurde.
Im Folgenden ein kleines Beispiel:
(defrule lion-eats
; Regel “lion-eats”
(present lion)
; Wenn eine Löwe vorhanden ist,
(hungry lion)
; der Löwe hungrig ist,
(present student)
; und ein Student anwesend ist,
=>
(assert (eats lion)))
; löse folgendes Ereignis aus: (auch „triggern“)
; Löwe isst (wird den Eigenschaften des Löwen mit
„(assert)“ hinzugefügt)
Was passiert nun, wenn zwei Regeln auslösen, die einander zunächst widersprechen?
Wenn z.B. eine Regel existiert, die besagt, dass der Student flüchten soll, wenn er einen
Löwen sieht?
3
Jess Tutorial, Seite 20
7
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
Für diesen Fall gibt es die Möglichkeit, Regeln mit einer Priorität auszustatten. Mit Hilfe
der „(salience)“ – Anweisung kann der Regel ein Wert für die Priorität zugeordnet werden.
Standardmäßig ist dieser Wert bei jeder Regel Null.
Würde die Regel „lion-eats“ mit der Anweisung „(salience 1)“ versehen, ist der Konflikt
gelöst und der Löwe gesättigt.
Ein weiteres wichtiges Kommando ist „(halt)“. Wie bereits erwähnt, läuft das System
solange noch Regeln aktiviert werden. Es kann aber sein, dass das eigentliche Ziel
bereits erreicht wurde (beispielsweise eine oder mehrere Variablen nun einen neuen Wert
haben). Für diesen Fall kann mittels „(halt)“ und „(salience)“ eine Stopregel geschaffen
werden. Diese sollte dann den höchsten Salience – Wert unter allen Regeln haben.
Da im Folgenden lediglich mit regelbasierten KS gearbeitet wird, sei noch einmal darauf
hingewiesen, dass es sich nicht um eine prozedurale Abarbeitung dieser Regeln handelt,
alle Regeln überwachen permanent den Status ihrer LHS.
3.2 JAVA Expert System Shell (JESS)
JESS ist vollständig zu CLIPS kompatibel, jedoch ist es auch als Source Code verfügbar.
Da
JESS
in
JAVA
entwickelt
wurde,
besitzt
es
den
Vorteil
einer
höheren
Plattformunabhängigkeit. Voraussetzung hierfür ist lediglich ein installiertes Java
Development Kit (JDK) ab Version 1.3.1. Derzeit läuft JESS unter den Betriebssystemen
Windows, Linux, Solaris und Mac OS.
Interessant ist JESS jedoch nicht allein wegen seiner JAVA – Implementierung, sondern
wegen der vielen Erweiterungen und Schnittstellen, die im Laufe der Zeit entwickelt
wurden.
Generell kann JESS COOL – Code, der für CLIPS entwickelt wurde, verarbeiten und
verfügt darüber hinaus aber noch über einen erwähnenswerten Unterschied:
Das Kommando „(run-until-halt)“; unter 3.1 wurde ausgesagt, dass das Expertensystem
solange laufen wird, bis entweder keine weiteren Regeln auslösen, oder es mittels des
„(halt)“-Kommandos beendet wurde. Mit dieser neuen Funktion ist es möglich, das
System auf die Eingaben eines Agenten warten zu lassen, die wieder neue Regeln
auslösen können. Damit nimmt JESS eine Sonderstellung in der Entwicklung vom
Expertensystem zu heutigen Agentensystemen ein.
8
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
3.3 JessTab
JessTab ist eine Schnittstelle zwischen dem Ontologie und Knowledge – Base Editor
Protégé-2000 und Jess.
Während der Begriff einer Knowledge – Base noch allgemein bekannt sein dürfte, so
scheint an dieser Stelle ein kleiner Exkurs zum Thema „Ontologie“ angebracht. Was ist
nun also eine Ontologie, und wozu wird sie verwendet?
Natalya F. Noy und Deborah L. McGuinness schrieben dazu4:
„Eine Ontologie definiert ein gemeinsames Vokabular für Forscher, die Informationen
innerhalb einer Domäne austauschen müssen. Sie schließt maschineninterpretierbare
Definitionen der grundlegenden Konzepte in der Domäne sowie die Beziehungen
innerhalb der Domäne mit ein.“
Ontologien ermöglichen somit:
•
Das Teilen einer gemeinsamen Informationsstruktur (innerhalb einer Gruppe von
Menschen oder unter Softwareagenten)
•
Die Wiederverwendbarkeit des Wissens einer Domäne
•
Trennung von Domänenwissen und operationalem Wissen
•
Die Analyse von Domänenwissen
Bei der Entwicklung eines Expertensystems ist die Verwendung einer Ontologie eine
wertvolle Hilfe bei der Strukturierung der zu verarbeitenden bzw. erzeugten Informationen.
JessTab stellt hierzu die folgenden Funktionalitäten bereit:5
•
es implementiert ein Jess Fenster in Protégé
•
es ermöglicht Jess, Knowledge Bases aus Protégé als Fakten in Jess zu übernehmen
•
und Jess – Regeln auf Protégé - Instanzen anzuwenden
Protégé-2000 erlaubt dem Benutzer darüber hinaus, eigene Formulare zur Sammlung von
Fakten zu erstellen, die in der Domäne enthaltenen Daten grafisch aufzubereiten und
Daten aus anderen Anwendungen oder Systemen zu übernehmen, die zu Protégé
kompatibel sind.
4 Aus Natalya F. Noy and Deborah L. McGuinness, Seite 1
5 Aus Henrik Eriksson: „JessTab Manual“
9
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
Protégé wird Bestandteil des Vortrages sein, bei dem einige seiner Funktionen am
Beispiel des im Folgenden angesprochenen Produktionsplanungssystems demonstriert
werden sollen.
4 Programmbeispiel: Produktionsplanungssystem
Das Programmbeispiel soll ein regelbasiertes Expertensystem zur Produktionsplanung
veranschaulichen.
Es
sei
angemerkt,
dass
dieses
Beispiel
lediglich
zur
Veranschaulichung der Vorgehensweise bei der Erstellung eines COOL – Projektes dient,
dieses relativ simple System lässt sich durchaus auch einfacher mit herkömmlichen
Programmieransätzen erstellen. Wie Daniel D. Corkill bereits schrieb6:
„Die Vorzüge eines Blackboardsystems zeigen sich nicht bei simplen Problemstellungen,
ihre Anwendung ist lediglich bei komplexen Anwendungen sinnvoll.“
Diese Aussage gilt auch für das verwendete Beispiel.
Problemstellung:
Betrachtet wird eine Firma, die Elektrowerkzeuge produziert, Bohrmaschinen und
Stichsägen. Diese werden in jeweils 3 Ausführungen mit unterschiedlicher Leistung
gefertigt. Die zur Produktion benötigten Teile können zum Teil in Eigenfertigung erstellt
werden bzw. von Zulieferern bezogen werden, teilweise ist nur ein Zukauf bzw.
ausschließlich Eigenfertigung möglich.
Die Firma verfügt über eine Produktionslinie, auf der sowohl die Bohrmaschinen als auch
die Stichsägen gefertigt werden, und über eine Werkstattfertigung zur Eigenproduktion
von Baugruppen.
Es ergeben sich folgende Optimierungsziele:
1. Minimierung von Rüstzeiten auf der Produktionslinie
2. Auslastung der Werkstattfertigung zwischen 90% und 105%
3. Termingerechte Auslieferung
Da die vollständige Umsetzung dieses Systems den Rahmen der vorliegenden Arbeit
sprengen würde, wird anhand eines Ereignisbaumes eine Übersicht über den
6
Aus Blackboard Systems, Seite 7
10
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
Lösungsansatz gegeben und skizziert, wie die Fact Knowledge Base und notwendige
Regeln entstehen.
Übersicht
Vorgehensweise
Im wesentlichen lässt sich das weitere Vorgehen in 3 Schritte aufteilen:
1. Erstellung der Fact Knowledge Base
2. Aufstellen der Regeln, denen das System folgen soll bzw. der Aktionen, die durch die
Regeln ausgelöst werden sollen
3. Umsetzung in COOL
11
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
Schritt 1: Erstellung der Fact Knowledge Base
Zunächst müssen alle Fakten gesammelt werden, die das System beeinflussen. Dies sind
hier z.B.: Stücklisten, Fertigungszeiten, Ressourcenverfügbarkeit, Maschinenzeiten etc.
Dann müssen diese Fakten strukturiert werden, und zwar so, dass sich das
Expertensystem später möglichst flexibel skalieren lässt.
Beginnen wir zunächst mit der Betrachtung des Fertigungsprogramms.
Produkt:
Modell:
Bohrmaschine
500W
Gehäuse
Motor
M500W
750W
1000W
GBM
M750W
M1000W
Getriebe
GBM1000W
Bohrfutter
BF1000W
Sägeblattaufnahme
Elektronik
EBM750W
EBM1000W
Stichsäge
500W
650W
M500W
Fertigung
LZ
EF
F
1/2
1
E
1
F
1
F
F
1
1
750W
GST
M650W
M750W
GST750W
SBA750W
EST650W
EST750W
Daraus lässt sich für jedes erstellte Erzeugnis eine eigene Stückliste ableiten. Jedes
Gerät besteht aus 5 Baugruppen, es werden in jeder Produktgruppe ca. 73 % Gleichteile
verwendet. (Der Übersichtlichkeit halber sind die benötigten Stückzahlen immer 1).
Aus der Betrachtung der Spalten Fertigung und LZ (Lieferzeit) ist bereits ein Engpass bei
der Fremdfertigung von Gehäusen zu erkennen, diese Erkenntnis wollen wir jedoch
zunächst zurückstellen.
Um die Stücklisten in unserer Knowledge Base verfügbar zu machen, benutzen wir die
„(deffacts)“ – Funktion. Mit dem folgenden Script können wir unsere Stücklisten anlegen:
(deffacts bm500w
(stkl-bm500w
GBM
M500W
GBM1000W
BF1000W
EBM750W)
)
12
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
(deffacts bm750w
(stkl-bm750w
GBM
M750W
GBM1000W
BF1000W
EBM750W)
)
usw.
Nachdem die Daten mittels des „(reset)“-Befehls in den Arbeitsspeicher geladen wurden,
kann man sich durch Eingabe von „(facts)“ die Stücklisten anzeigen lassen, was etwa so
aussieht:
f-0
(initial fact)
f-1
(stkl-bm500w GBM M500W GBM1000W BF1000W EBM750W)
f-2
(stkl-bm750w GBM M750W GBM1000W BF1000W EBM750W)
usw.
Schritt 2: Aufstellen der Regeln
Hier kann man im Wesentlichen dem oben abgebildeten Entscheidungsbaum folgen.
Als Beispiel für eine einfache Regel könnte eine Abfrage nach der Gültigkeit des
Bestelldatums dienen:
(defrule chk-date
(today > orderdate)
=>
(retract (?order)))
; Regel “Datumscheck”
; Wenn das Bestelldatum vor dem heutigen Tag liegt,
; löse folgendes Ereignis aus
; Entferne Auftrag aus System
Ich habe mich an dieser Stelle auf ein kurzes Beispiel beschränkt, da das System
zusammen mit Protégé während des Vortrages präsentiert werden soll.
13
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
5 Fazit
Expertensysteme dürfen wohl zu recht als Wegbereiter heutiger Agentensysteme
bezeichnet werden. Viele Eigenschaften heutiger Agenten wiesen schon die Knowledge
Sources der Expertensysteme auf, so zum Beispiel die Unabhängigkeit der KS
voneinander und die große Bandbreite der Möglichkeiten, innerhalb einer KS zu
Lösungsansätzen zu kommen.
Klassische Expertensysteme wurden mittlerweile von Agentensystemen abgelöst, die
flexibler sind. Einer der größten Schwachpunkte war die Kommunikation, die bei den
Knowledge Sources immer über eine zentrale Instanz abgewickelt wurde, während
heutige Agenten untereinander kommunizieren können.
JESS darf dank seiner JAVA – bedingten Flexibilität als Meilenstein im Übergang von
Experten- hin zu flexiblen Agentensystemen gesehen werden; hier wurde erstmals die
Implementierung von Agenten vorgesehen. Nicht zuletzt deshalb gibt es immer noch eine
sehr aktive Entwicklergemeinde, die eine große Bandbreite an Tools zur Benutzung mit
JESS entwickelt hat.
14
Seminararbeit zum Thema: Programmierung von Expertensystemen am Beispiel von CLIPS
Dirk Weil
AG 4, betreut durch Dipl. Kfm. Tim Stockheim
Seminar Automatisierte Ressourcenallokation, unter der Leitung von Prof. Dr. König
6
Literaturliste
Corkill, Daniel D.: Blackboard Systems (leider sind weder in der Arbeit noch auf der
Website Daten zur Veröffentlichung zu finden)
http://dancorkill.home.attbi.com/pubs/ai-expert.pdf
Achieving Flexibility, Efficiency, and Generality in Blackboard Architectures, Daniel D.
Corkill, Kevin Q. Gallagher, and Philip M. Johnson. In Proceedings of the National
Conference on Artificial Intelligence (AAAI-87), pages 18-23, Seattle, Washington, July
1987. (Also published in Readings in Distributed Artificial Intelligence, Alan H. Bond and
Les Gasser, editors, pages 451-456, Morgan Kaufmann, 1988.)
http://dancorkill.home.attbi.com/pubs/aaai87.pdf
Functionally Accurate, Cooperative Distributed Systems, Victor R. Lesser and Daniel D.
Corkill. IEEE Transactions on Systems, Man, and Cybernetics, SMC-11(1):81-96, January
1981.
http://dancorkill.home.attbi.com/pubs/smc-fac.pdf
Ontology Development 101: A Guide to Creating Your First Ontology, Natalya F. Noy and
Deborah L. McGuinness Stanford University, Stanford, CA, 94305
http://protege.stanford.edu/publications/ontology_development/ontology101.pdf
Jess Tutorial, Maarten Menken, Vrije Universiteit, Amsterdam, The Netherlands,
July 22, 2002
http://www.cs.vu.nl/~ksprac/doc/tutorial/jess-tutorial.pdf
Clips Reference Manual, Volume I: Basic Programming Guide, Version 6.10,
August 5th 1998
http://www.cs.sun.ac.za/~rdodds/RW262/bpg.pdf
15