Fuzzylogik und Regelbasierte Systemesierte Systeme, die f ur das Verst andnis der Ausarbeitung...

Fuzzylogik und Regelbasierte Systeme

Ausarbeitung fur das Masterprojekt:

Thomas BeermannDennis HuningDennis Lohr

Inhaltsverzeichnis

I. UbersichtAutor: Dennis Lohr, B.Sc. 2

1. Ubersicht 31.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2. Fuzzy-Logik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1. Klassische Logik vs. Fuzzy-Logik . . . . . . . . . . . . . . . . . . . 31.2.2. Fuzzysets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.3. Fuzzifizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.4. Defuzzifizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.5. Fuzzy Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2.6. Fuzzy-Controlling . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.2.6.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . 61.2.6.2. Implikation . . . . . . . . . . . . . . . . . . . . . . . . . . 71.2.6.3. Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . 7

1.3. Regelbasierte Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3.2. Die Regelbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.3.3. Die Faktenbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.3.4. Inferenzmaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.3.4.1. Vorwartsverkettung . . . . . . . . . . . . . . . . . . . . . 111.3.4.2. Ruckwartsverkettung . . . . . . . . . . . . . . . . . . . . 12

1.3.5. Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.3.6. Herkunft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.4. Jefis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

II. Jefis Drools AdapterAutor: Dennis Huning, B.Sc. 14

2. Jefis Drools Adapter 152.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.2. Der Rete-OO Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.2.1. Uberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.2.2. Erzeugen eines deterministischen Baumes . . . . . . . . . . . . . . 15

ii

Inhaltsverzeichnis

2.2.3. Laufzeit Ausfuhrung . . . . . . . . . . . . . . . . . . . . . . . . . . 162.2.4. Beispiel eines Baumes . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.3. Erweiterung des Rete-OO Algorithmus um Fuzzy Logik . . . . . . . . . . 182.4. Drools Chance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.5. Adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

III. Jefis RuleengineAutor: Dennis Lohr, B.Sc. 22

3. Jefis Ruleengine 233.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.2. Beispiel in Lab4Jefis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.3. Die Lab4Jefis Rule-Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

IV. FCL und ANTLRAutor: Thomas Beermann, B.Sc. 27

4. FCL und ANTLR 284.1. FCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.1.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.1.2. Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.1.3. Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4.1.3.1. VAR INPUT / VAR OUTPUT . . . . . . . . . . . . . . 304.1.3.2. FUZZIFY / DEFUZZIFY . . . . . . . . . . . . . . . . . . 304.1.3.3. RULEBLOCK . . . . . . . . . . . . . . . . . . . . . . . . 31

4.2. ANTLR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.2.1. Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.2.2. Lexer/Parser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.2.3. Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.2.4. Benutzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.2.5. Treewalker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.2.6. Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

V. Anhang 38

5. ANTLR 39A. Fcl.g . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39B. FCLTreeWalker.g . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

6. Jefis Ruleengine 45

Abbildungsverzeichnis 46

iii

Inhaltsverzeichnis

Literaturverzeichnis 47

iv

Einleitung

Diese Ausarbeitung dokumentiert das Masterprojekt 2009/2010 im Labor fur Informatikan der Fachhochschule Munster - Fachbereich Elektrotechnik und Informatik. Thema desMasterprojektes war es Fuzzy-Logik und klassische Regelbasierte Systeme zu verbinden.Das Kapitel 1 beschreibt dafur die Grundlagen im Bereich Fuzzy-Logik und Regelba-sierte Systeme, die fur das Verstandnis der Ausarbeitung erforderlich sind.Nachfolgend stellt das Kapitel 2 den ersten Teil bzw. das erste Semester des Masterpro-jektes dar. Hierbei geht es hauptsachlich um die Fuzzy-Erweiterung von drools:chance,das ein Unterprojekt von Drools 1 ist.Im Weiteren wird das zweite Semester geschildert. Nach dem Abschluss des drools:chanceProjektes wurde das Projekt Jefis um Ruleengine Funktionalitaten erweitert. Das Kapi-tel 3 beschreibt, wie die Ruleengine fur Jefis implementiert wurde und gibt zum Schlussnoch ein ausfuhrliches Beispiel fur die Benutzung.Ein wichtiger Bestandteil der Ruleengine ist es Regeln und Fuzzysets aus einer Dateiauslesen zu lassen. Dafur war es notwendig eine einheitliche Form zu bestimmen, die inder Fuzzy Control Language (FCL) gefunden wurde, beschrieben in Kapitel 4.1. Zuletztbestand dann noch das Problem diese FCL-Dateien mit Java auszulesen und in Jefis-Objekte umzuwandeln. Aus verschiedenen Grunden, erlautert in Kapitel 4.2, wurde dafurANTLR genommen.

1http://www.jboss.org/drools

1

Teil I.

UbersichtAutor: Dennis Lohr, B.Sc.

2

1. Ubersicht

1.1. Einleitung

Dieses Kapitel gibt eine Ubersicht uber die notwendigen Grundlagen um den weite-ren Teil der Ausarbeitung nachzuvollziehen. Es werden grundlegende Aspekte von Fuz-zy erklart, wie beispielsweise Fuzzysets, Fuzzifizierung oder Fuzzy-Operatoren. Im Ab-schnitt Regelbasierte Systeme werden Themen wie Faktenbasis, Inferenzmaschinen undVorwartsverkettung erlautert. Abschließend gibt der Abschnitt Jefis einen Uberblickuber das im Labor fur Informatik der FH-Munster entstandene gleichnamige Projekt.

1.2. Fuzzy-Logik

1.2.1. Klassische Logik vs. Fuzzy-Logik

In der klassischen Logik kann ein Element x ∈ X entweder einer bestimmten MengeA zugeordnet werden oder nicht. Schnell ist ersichtlich, dass es in vielen Fallen einerweicheren Betrachtung bedarf. Als Beispiel sei hier eine Regel zur Luftersteuerung ge-nannt, die Regel besagt, dass die Kuhlung ab einer Temperatur großer 80◦C angeschaltetwird. Eine minimale Abweichung um -0,0001◦ von der kritischen Temperatur wurde inder klassischen Logik nicht zum Einschalten der Kuhlung fuhren. Wodurch es in diesemBeispiel zu einer unnotig langen thermischen Uberstrapazierung der CPU und darausresultierend zu einer schnelleren Alterung kommt.Ein anderes Systemverhalten ist in der klassischen Logik nicht moglich, da fur die Indi-katorfunktion oder Charakteristische Funktion χA der Menge A gilt:

χA : X → {0, 1}

χA(x) ={

1 : x ∈ A0 : x /∈ A

}Um eine solche Einschrankung zu umgehen, erweitert die Fuzzy-Logik die zweielementigeMenge {0, 1} auf das abgeschlossene Intervall I:= [0, 1]. Die so entstehende LosungsmengeA wird als Fuzzy-Menge bezeichnet und besteht aus geordneten Paaren der Form:

A = {(x, µA(x)) ∧ x ∈ X}

Durch µ ist auf dieser Menge eine Funktion definiert, die den Grad angibt, zu dem ein Ele-ment x ∈X in der Menge A enthalten ist. Die Funktion µ wird als Zugehorigkeitsfunktionbezeichnet.

3

KAPITEL 1. UBERSICHT

Abbildung 1.1.: Beispiel Fuzzy Partition fur einen Wertebereich von 0 bis 80

1.2.2. Fuzzysets

Damit die Zugehorigkeitsfunktion uberhaupt den Wert der Zugehorigkeit ermitteln kann,muss uber der Menge A eine beliebige Funktion beschrieben werden. Eine solche Funk-tion wird als Fuzzyset bezeichnet. Mehrere Fuzzysets werden zu einer Fuzzy Partitionzusammengefasst.In der Abbildung 1.1 wird eine Beispiel Partition mit drei Fuzzysets gezeigt. Wie das

Beispiel zeigt konnen beliebige Funktionen genutzt werden um ein Fuzzyset zu beschrei-ben. Zusatzlich sieht man, dass ein Wert mehrere Zugehorigkeitswerte haben kann, z.B.fur den Wert 45 liefert µ(45) = {0, 0.7, 0.5}. Das bedeutet, dass der Eingabewert von45 zu 0% im ersten Fuzzyset, zu 70% im Fuzzyset zwei und zu 50% im dritten Fuzzysetliegt.

1.2.3. Fuzzifizierung

Bei der Fuzzifizierung wird fur einen scharfen Wert in einem dazugehorigen Fuzzysetdie Zugehorigkeit ermittelt, dafur wird aber erstmal ein Eingabe-Fuzzyset benotigt. Indiesem Fuzzyset wird der Zugehorigkeitsgrad wie in Abbildung 1.1 bestimmt. Hierbeiwird von der X-Achse bei dem scharfen Wert senkrecht bis zu dem Fuzzyset gegangenund dann die Zugehorigkeit auf der Y-Achse abgelesen. Hierbei konnen verschiedeneVerfahren benutzt werden um dies dann in ein Eingabe-Fuzzyset umzuwandeln. Einesdieser Verfahren funktioniert so: Das betreffende Eingabe Fuzzyset dadurch gebildetwird, dass das zugehorige Fuzzyset bis zur Zugehorigkeit gefullt wird. Bei einem weiteremVerfahren wird das zugehorige Fuzzyset mit der Zugehorigkeit Multipliziert. Es gibt nochandere Verfahren die hier allerdings nicht weiter beschrieben werden.

1.2.4. Defuzzifizierung

Fur die Defuzzifizierung gibt es auch mehrere Methoden dies zu machen die wohl amweitesten verbreitete Methode ist die Schwerpunktmethode (center of gravity). Die De-fuzzifizierung eines Sets sehen wir in Abbildung 1.2. In diesem Beispiel wurde die Schwer-punktmethode verwendet, durch die Verteilung und den Fullstand der Sets ergibt sichder Schwerpunkt bei 28,57%. Zusatzlich zu dieser gibt es auch noch die Maximum Metho-de, hierbei wird das Maximum innerhalb des Fuzzysets gesucht und als defuzzifizierterWert zuruckgegeben. Dabei gibt es drei Methoden:

4


Abbildung 1.2.: Beispiel Defuzzifizierung uber die Schwerpunktmethode 1

x y x ∧ y x ∨ y ¬ x0 0 0 0 10 1 0 1 11 0 0 1 01 1 1 1 0

Tabelle 1.1.: Wahrheitstabelle der klassischen Logik

1. Linkes Maximum - hier wird von links das Maximum gesucht.

2. Rechtes Maximum - hier wird von rechts das Maximum gesucht.

3. Mittleres Maximum - hier wird erst das linke und das rechte Maximum gesuchtund anschließend der Mittelwert gebildet.

1.2.5. Fuzzy Operatoren

In der klassischen Logik ist es moglich mehrere Elemente verschiedener Mengen uberdie Operatoren ”∨, ∧ und ¬“, zu verknupfen (Tabelle 1.1). Da die Fuzzy-Logik nichtaus einer endlichen Mengen von Moglichkeiten besteht wird schnell ersichtlich, dass mandie Operatoren nicht eins zu eins auf die Fuzzy-Logik uberfuhren kann. Daher mussenspezielle Operatoren eingefuhrt werden, die die gleichen Ergebnisse wie in Tabelle 1.1liefern.

Eine Losung dieses Problems ist es die Operatoren durch die in Tabelle 1.2 gezeigtenFunktionen zu ersetzen. Die sich dadurch ergebene Wahrheitstabelle wird in Tabelle 1.3gezeigte. Wie man leicht erkennen kann, liefern die Funktionen fur die Grenzwerte 0 und1 die gleichen Ergebnisse. Diese Norm wird auch MINMAX-Norm genannt.

1Quelle der Graphik ist das Labor fur Prozessinformatik und Prozesslenkung, FH-Munster - FachbereichElektrotechnik und Informatik

5


x ∧ y min(x,y) t-Normx ∨ y max(x,y) s-Norm¬ x 1-x c-Norm

Tabelle 1.2.: Abbilden der Operationen auf Funktionen

x y min(x,y) max(x,y) 1-x0 0 0 0 10 1 0 1 11 0 0 1 01 1 1 1 0

0.2 0.5 0.2 0.5 0.80.7 0.2 0.2 0.7 0.30.6 0.6 0.6 0.6 0.4

Tabelle 1.3.: Wahrheitstabelle der Fuzzy-Logik

1.2.6. Fuzzy-Controlling

1.2.6.1. Einleitung

Fuzzy-Controlling wird in der Elektrotechnik seit den 1970er Jahren eingesetzt. Zu Be-ginn aber fast ausschließlich im asiatischen Raum. In der Elektrotechnik werden Fuzzy-Controller als Regler eingesetzt, wobei diese genauso wie andere Regler auch mit scharfenEingabewerten versorgt werden.

Abbildung 1.3.: Beispiel Fuzzy-Regler in einem Schaltbild

Aber anders als bei anderen Reglern fuzzifiziert der Fuzzy-Regler die Eingabewertebevor er mit den Daten arbeitet. Wenn die Eingabedaten dann fur den Fuzzy-Regleraufbereitet wurden, verarbeitet der Regler die Eingaben mit seinen Regeln. Nachdemdie internen Regeln des Fuzzy-Reglers dann abgearbeitet sind, werden die Ausgabewer-te defuzzifiziert. Das Defuzzifizieren wird gemacht um wieder scharfe Werte fur z.B.eine Motorsteuerung zu erhalten. Auch beim Fuzzy-Controlling ist es moglich Fuzzy-Regler zu verketten, um so eine Hintereinanderausfuhrung von verschiedenen Regeln zuermoglichen. Das wird allerdings in der Praxis nicht gemacht da dies nur die Komplexitatdes Systems unnotig steigern wurde.

6


1.2.6.2. Implikation

Die Implikation ist der Kernbestandteil des Systems, hier gibt es eine Vielzahl an ver-schiedenen Verfahren. Einige dieser Verfahren sind Goedel,Lucasiewicz oder Zadeh, intechnischen Systemen wird aber meist nur Larsen oder Mamdani eingesetzt. Wobei dieMamdani Implikation die am meisten genutzte in der Elektrotechnik ist.

Allgemein beschrieben wird bei der Implikation bestimmt, zu welchem Anteil die ein-zelnen Werte innerhalb eines Fuzzysets erfullt sind. Bei der Mamdani Implikation

µA⇒B(x, y) := min{µA(x), µB(x)}

wird beispielsweise ein Wert innerhalb eines Fuzzysets bis zum Maximum der Schnitt-menge gefullt.

1.2.6.3. Anwendungen

In der Elektrotechnik werden Fuzzy-Systeme mit den folgenden Vor- bzw. Nachteilenbeschrieben. Vorteile sind, dass Losungen auch moglich sind, wenn

• Kein in sich geschlossenes mathematisches Modell des Prozesses, z.B. in Formvon Differentialgleichungen, existiert oder gefunden werden kann, oder wenn dieKomplexitat des Problems fur eine solche Modellierung zu groß ist.

• Unscharfe und vage Aussagen oder intuitive Einschatzungen zur Modellierung desSachverhalts herangezogen werden mussen.

• Viele Eingangsparameter und hohe Nichtlinearitat vorliegen.

Nachteile sind:

• Die Beliebigkeit bzw. die Freiheit, die der Entwickler bei der Wahl und Implemen-tierung des Fuzzy-Modells hat. Es existieren keine standardisierten Vorgehens-weisen, um Erfahrungswissen in die Daten- und Regelbasis eines Fuzzy-Systemsumzusetzen.

• Die Beliebigkeit bzw. die Freiheit, die der Entwickler bei der Modifizierung einesFuzzy-Modells zur Feinabstimmung oder Ergebnisverbesserung hat. Hierzu existie-ren ebenfalls keine standardisierten Methoden. Die Anpassung eines Fuzzy-Modellsan veranderte Parameter kann daher schwierig und zeitaufwendig werden oder auchscheitern.

• Fuzzy-Systeme besitzen keine Lernfahigkeit, die Regeln und Zugehorigkeitsfunk-tionen mussen vom Entwickler entworfen und optimiert werden.

[Nel05]Auch bei Systemen bei denen man annehmen wurde, dass dort besonders auf eine

mathematische Beweisbarkeit geachtet wird gibt es Gegenbeispiele. Eines dieser Gegen-beispiele ist ein Raketen Zielsystem. In der Diplomarbeit von Alfons Mollers2 wurde ein

2Quelle fur das Beispiel ist die Diplomarbeit von Alfons Mollers an der FH Munster aus dem Jahr 1995

7


Abbildung 1.4.: Flugbahn und Geschwindigkeitskorrektur uber Fuzzy

Abbildung 1.5.: Schaltplan der Flugbahn und Geschwindigkeitskorrektur

Problem beschrieben bei dem Es die Aufgabe war ein System zu entwerfen, dass dieGeschwindigkeit eines Flugobjekts so anpasst das dieses zum richtigen Zeitpunkt amZiel ankommt. Hierbei muss man jedoch erwahnen das durch einen Fuzzy-Regler nurKorrekturwerte an die eigentliche Flugkontrolle geliefert werden und nicht das ganzeSystem auf Fuzzy-Controlling basiert.

Ein weiteres Beispiel ist das inverse Pendel3. In einem Versuchsaufbau an der Fach-hochschule Munster ist es sogar moglich, ein gefulltes Bierglas auf das inverse Pendel zustellen, wie in Abbildung 1.6 zu sehen ist.

Beim Versuchsaufbau wird an einem beweglichen Schlitten uber ein Kugellager eineStange befestigt. Ziel des Systems ist es die Stange in eine aufrechte Position zu bekom-men. Dies gilt als schones Beispiel, denn uber eine normale Regelung ist es nicht moglichden gesamten Vorgang in einen Regler abzubilden. Da es sich bei Normalen Regler meistum lineare Systeme handelt. Wenn dieses Problem versucht wird uber normale Regler

3Quelle fur das Beispiel ist die Diplomarbeit von Stefan Tombrock an der FH Munster aus dem Jahr1996

8


zu losen, ist hierfur notwendig das die zugehorigen Differentialgleichungen fur viele Po-sitionen linearisiert wird. Durch den Einsatz von einem Fuzzy-Regler ist es moglich, dasGanze in einem Regler zu implementieren. Eine Losung hierfur ist das Aufstellen derRegeln die in Abbildung 1.7 zu sehen sind, zusammen mit den Fuzzysets aus Abbildung1.6.

Abbildung 1.6.: Bierglas auf Inversen Pendel; Fuzzysets des Beispiels

Abbildung 1.7.: Regeln des Inversen Pendels

1.3. Regelbasierte Systeme

1.3.1. Einleitung

Ein Regelbasiertes System besteht aus einer Faktenbasis, einer Regelbasis und einerInferenzmaschine. Hierbei stellt die Inferenzmaschine den Kern des Systems dar, da

9


die Inferenzmaschine aus den in der Regelbasis enthaltenen Regeln zusammen mit dengegebenen Fakten Schlussfolgerungen bildet. Hierbei wird beispielsweise aus dem Fakt,dass es gerade regnet gefolgert, dass die Straßen nass sind. Was im weiteren Verlauf nochgenauer erklart wird.

Abbildung 1.8.: Komponenten eines Regelbasierten Systems [Bec]

1.3.2. Die Regelbasis

ist eine Sammlung von Wissen. Diese Regeln sind folgendermaßen aufgebaut:

WENN (Pramisse / Voraussetzung)DANN (Konklusion durch eine Aktion).

Sollte das Wissen nicht in dieser Form vorliegen so muss es umgeformt werden, dieswird beispielsweise aus dem Wissen ”Alle Vogel konnen fliegen“ =⇒ ”Wenn ein Tier einVogel ist, dann kann es fliegen“. Diese Regeln werden aber nicht einfach fest integriert,sondern dynamisch hinzugefugt. Dadurch ist es moglich das System auf viele spezielleAnwendungsgebiete anzupassen oder das System an sich andernde Anforderungen an-zupassen. Dies ist auch notwendig, denn einer IDC-Studie zufolge andern sich ca. 45%aller Regeln in einem Release-Zyklus [DWM08].

Aktuelle Beispiele fur Systeme bzw. Notationen, mit denen Regeln erstellt werdenkonnen sind: JBOSS-Rules, Ross-Notation, AORML - Agent Object Relationship Mo-deling Language , ORM - Objekt Role Modeling Language und URML - UML-BasedRule Modeling Language. [Dre].

10


1.3.3. Die Faktenbasis

setzt sich aus allen bekannten Fakten zusammen. Hierbei kann es sich sowohl um Mess-werte, Symptome oder auch um Ergebnisse aus vorherigen Berechnungen handeln. Zudem gibt es auch Regelsysteme die gezielt Fragen stellen, um beispielsweise medizinischeDiagnosen zu stellen. Ein Beispiel ist hierfur das medizinische Diagnosesystem MYCIN.MYCIN ist in den 70er Jahren als ein Konsultationssystem zur Diagnose und Therapievon Infektionskrankheiten durch Antibiotika entwickelt worden. [Bei06]

Durch die Trennung des Wissens, was in den Regeln definiert ist und dem Verarbeitendes Wissens in der Inferenzmaschine werden einige Eigenschaften von RegelbasiertenSystemen begrundet. Folgende Eigenschaften von Regelsystemen stammen von TorbenPullmann [Pul00]

• Transparenz: Aufgrund der transparenten Wissensreprasentation kann das Verhal-ten von wissensbasierten Systemen in einfacher Weise erklart und vorhergesagtwerden.

• Flexibilitat: Wissen kann in einfacher Weise hinzugefugt und entfernt werden.

• Benutzerfreundlichkeit: Der Umgang mit wissensbasierten Systemen erfordert keinprogrammiertechnisches Vorwissen.

• Kompetenz: Wissensbasierte Systeme verfugen in ihrem Anwendungsbereich ubereine hohe Problemlosungsfahigkeit.

1.3.4. Inferenzmaschine

Fur die Inferenzmaschine selbst gibt es zwei grundsatzliche Vorgehensweisen, die Vor-wartsverkettung und die Ruckwartsverkettung. Bei der Vorwartsverkettung wird ver-sucht aus den vorhandenen Informationen, durch die Auswertung neue Informationenzu generieren. Das Verfahren wird auch in Abbildung 1.8 verwendet. Ein Beispiel furdieses Verfahren ist. Aus den Regeln:

1. Wenn man viel Schokolade isst, dann nimmt man viele Kalorien auf.

2. Wenn man viele Kalorien aufnimmt, dann wird man dick.

Wenn jetzt bekannt ist, dass jemand viele Kalorien zu sich nimmt, folgern wir aus derzweiten Regel, dass diese Person dick ist. Dies ist die einfache Inferenz, da hier nochnicht das Ergebnis einer anderen Regel ausgewertet wird.

1.3.4.1. Vorwartsverkettung

Wenn aber die Inferenzmaschine die Vorwartsverkettung verwendet, brauch nur bekanntsein, dass eine Person viel Schokolade isst. So konnen wir daraus folgern, dass diese Per-son viele Kalorien zu sich nimmt und daraus wieder das diese Person dick ist. DiesesVerfahren hat aber einen Nachteil, um beispielsweise einen bestimmten angestrebtenZustand zu erreichen, mussten bei der Vorwartsverkettung alle Moglichkeiten der Fak-tenbasis durchgegangen werden.

11


1.3.4.2. Ruckwartsverkettung

Dies wird von der Ruckwartsverkettung besser behandelt. Haben wir wieder die vorherigeRegel gegeben und der Zustand den wir anstreben ist es herauszufinden, warum einebestimmte Person ubergewichtig ist, so konnen wir unsere Regeln auswerten, die dasgewunschte Ergebnis haben. In diesem Fall ware das die zweite Regel, die besagt ”Wenneine Person viele Kalorien zu sich nimmt, dann wird sie dick“. Aber das ist nicht dieeinzige Moglichkeit, sondern wir haben noch die Regeln, die die Pramisse der zweitenRegel als Konklusion haben, was bei der ersten Regel gegeben ist. Daraus ergibt sichdas Ergebnis mit dieser Regelbasis, dass eine Person dick ist, wenn sie viele Kalorien zusich nimmt oder viel Schokolade isst.

1.3.5. Zusammenfassung

Zusammengefasst bezeichnet der Begriff der Inferenz das Gewinnen von neuen Faktenaus alten Fakten. Um die Faktenbasis zu erweitern und noch mehr Fakten zu erzeugen.Um eine Schleifenbildung zu verhindern, die im Normalfall auftreten wurde, wird einBeispiel gegeben. Als Regeln gelten wieder die beiden bekannten:

1. Wenn man viel Schokolade isst, dann nimmt man viele Kalorien auf.

2. Wenn man viele Kalorien aufnimmt, dann wird man dick.

Wenn in diesem Fall die Faktenbasis den Input bekommt, dass jemand viel Schokoladeisst, generiert die erste Regel daraus, dass diese Person viele Kalorien zu sich nimmt.Fur die nachste Iteration haben wir also in der Faktenbasis das Wissen, dass eine Personviel Schokolade isst und viele Kalorien zu sich nimmt, damit konnen wir jetzt beideRegeln wieder ausfuhren. Damit wurde also eine Endlosschleife laufen, da kein Wissenaus der Faktenbasis entfernt wird. Aus diesem Grund wird bei einer Inferenzmaschinenoch eine Konfliktmenge gebildet. Die Konfliktmenge stellt die aktiven Regeln dar, andem Beispiel erklart heißt das fur die Faktenbasis und die Konfliktmenge, dass sie leersind. Geben wir nun zur Faktenbasis die Information hinzu, dass jemand viel Schokoladeisst, so werden der Konfliktmenge auch alle Regeln hinzugefugt, die von der aktuellenFaktenbasis bedient werden konnen. Nachdem dann die Regeln aus der Konfliktmengegefeuert wurden, werden die neu gewonnenen Informationen der Faktenbasis hinzugefugt.Dabei werden alle vorherigen aktiven Regeln aus der Konfliktmenge entfernt und imAnschluss die Regeln hinzugefugt die durch die neuen Informationen gefeuert werdenkonnen. Damit wurde also nach der ersten Iteration bzw. dem Ausfuhren der ersten Regelnur die zweite Regel in der Konfliktmenge enthalten sein, wodurch wir das Problem derEndlosschleife fur dieses einfache Beispiel gelost haben.

1.3.6. Herkunft

Als Geburtsstunde der kunstlichen Intelligenz wird ein Workshop in Dartmouth im Som-mer des Jahres 1956 angesehen, der von John McCarthy, Marvin Minsky, Nathan Ro-chester und Claude Shannon organisiert wurde. Durch diesen Workshop hat sich auch

12


der englische Name ”artificial intelligence” durchgesetzt. Vor diesem Workshop wurdenComputer nur als arithmetische Rechenmaschinen angesehen. Nach diesem Workshopaber haben die Teilnehmer, an verschiedenen Einrichtungen, versucht dem Computer mitWissen uber einzelne Fachgebiete zu versehen, woraus auch die Regelbasierten Systemeentstanden. Das erste System, das erfolgreich intensiv Wissen in der Form einer großenAnzahl von Regeln aus einem spezifischen Anwendungsbereich einsetze, war DENDRAL.Das DENDRAL Projekt wurde in den 1960er Jahren gestartet und interpretiert Aus-wertungen von Massenspektrometern. [Bei06]

1.4. Jefis

Jefis (Java Expert Fuzzy Inference System) ist ein Projekt der FH-Munster 4. DasProjekt beschaftigt sich mit Fuzzylogic. Wie in Abbildung 1.9 zu sehen ist, ist dasFuzzyset einer der zentralen Bestandteile des Systems. Es unterstutzt eine Vielzahl vonverschiedenen Implikationen wie beispielsweise Goedel, Lucasiewicz, Larsen, Mamdaniund noch einige mehr. Diese Vielfalt setzt sich bei den Normen fort, hier gibt es dieNormen Algebraic, Bounded oder MinMax um nur einige zu nennen. Des Weiteren sindElemente zur Visualisierung enthalten mit denen sich Beispiel Applets in kurzer Zeiterstellen lassen. Ein Beispiel fur die Visualisierung lasst sich in Abbildung 3.1 finden.

Abbildung 1.9.: UML Diagramm der wichtigsten Jefis Klassen [NW09]

4Jefis ist ein Projekt des Labor fur Informatik das zu finden ist unter http://www.lab4inf.fh-muenster.de

13

Teil II.

Jefis Drools AdapterAutor: Dennis Huning, B.Sc.

14

2. Jefis Drools Adapter

2.1. Einleitung

Das erste Kapitel hat einen Uberblick uber die grundlegenden Themen des folgendemKapitels gegeben. In diesem Kapitel wird kurz der Rete-OO Algorithmus angeschnitten,da dieser in JBoss Drools verwendet wird und alle folgenden Abschnitte in diesem Kapitelauf diesem Projekt basieren. Anschließend wird auf die Kombination von RegelbasiertenSystemen und Fuzzy eingegangen, im Speziellen auf die Arbeit von Davide Sottara 2.3und den im Masterprojekt 2009/10 entstandenen Adapter des Jefis-Projektes 2.5.

2.2. Der Rete-OO Algorithmus

2.2.1. Uberblick

Der Rete-OO ist eine fur objektorientierte Systeme optimierte Version des Rete PatternMatching Algorithmus und wird in der Business-Rule-Engine JBoss Drools eingesetzt.Erfunden wurde der Rete Algorithmus von Dr. Charles Forgy. Der eigentliche Algorith-mus kann in zwei Aufgaben aufgeteilt werden:

• Erzeugen eines deterministischen Baumes

• Laufzeit Ausfuhrung

2.2.2. Erzeugen eines deterministischen Baumes

Wahrend der ersten Ausfuhrungsphase wird aus den Bedingungen der LHS aller Re-geln eine Baumstruktur erzeugt, dabei entspricht jeder Knoten einer Teilbedingung(Pramisse). Die LHS einer speziellen Regel ergibt sich aus der Verknupfung einzelnerPfade. Zusatzlich werden gleiche Bedingungsteile von unterschiedlichen Knoten geteilt.In der Literatur wird vom Nodesharing gesprochen. Rete-OO kennt insgesamt die achtin der Abbildung 2.1 gezeigten Knoten.In jedem Baum ist der erste Knoten der ReteNode. Dieser Knoten errechnet fur je-

des Objekt, das zum WorkingMemory hinzugefugt wird, den zugehorigen Hashwert undspeichert diesen. Durch diese Maßnahme wird sichergestellt, dass kein gleiches Faktumzweimal den Baum durchlauft. In der zweiten Ebene befinden sich die ObjectTypeNodesdie eine instanceof -Prufung durchfuhren. Somit kann jeder Pfad nur von dem Faktumdurchlaufen werden an dem eine objektspezifische Prufung erfolgreich durchgefuhrt wer-den kann.AlphaNodes fuhren eine atomare Uberprufung an einer Membervariable durch. Trifft

15

KAPITEL 2. JEFIS DROOLS ADAPTER

Abbildung 2.1.: Auflistung der unterschiedlichen Rete-OO Knoten

die abgefragte Bedingung zu, wird das Faktum im sogenannten AlphaMemory abgespei-chert. Zusatzlich propagiert ein AlphaNode, falls das Faktum die Bedingung erfullt hat,dieses zu seinem Nachfolger.BetaNodes (JoinNodes) stellen eine Verbindung zwischen Gruppen aus einem oder meh-reren Tupeln und eindeutigen Fakten her. Tupel werden an dem linken und Fakten amrechten Eingang angelegt. Auch BetaNodes verfugen uber einen Speicher. Fur die Datenvom linken Eingang heißt dieser Speicher BetaMemory. Die Daten vom rechten Eingangwerden im AlphaMemory gespeichert. Daher enthalt der BetaMemory alle eingehendenTupel und der AlphaMemory alle eingehenden Objekte.LeftInputAdapterNodes bekommen ein Objekt ubergeben und propagieren nur ein ein-zelnes Objekttupel weiter an den darunter liegenden Knoten.Jeder Pfad endet mit dem TerminalNode. Dieser Knoten ist mit einer bestimmten Regelverknupft. Sobald der Knoten aktiviert wird, fugt der Algorithmus die mit der Termi-nalNode verknupften Regel zur Konfliktmenge hinzu.

2.2.3. Laufzeit Ausfuhrung

Wahrend der Laufzeit Ausfuhrung durchlauft der Rete-Algorithmus drei Phasen:

Match: Inhalt des WorkingMemories (WM) wird auf alle LHS angewendet. Als Resultatwird eine Menge (Conflict-Set), bestehend aus den Regeln deren LHS Wahrheits-wert gleich ”wahr“ ist, geliefert.

Conflict-Resolution: Es wird eine Regel aus der Konfliktmenge zum Ausfuhren aus-gewahlt.

Act: Es wird die ausgewahlte Regel ausgefuhrt. Dies hat zur Folge, dass sich der Statusdes WM andert, wodurch ein Rematching getriggert wird.

Zu beachten ist hierbei, dass 90% der Rechenzeit fur die Matching-Phase benotigt wird.

16


2.2.4. Beispiel eines Baumes

In der Software Drools [dro10] werden die Regeln in der Drools Rule Language (DRL)verfasst. Dabei werden die Regeln standardmaßig im MVEL-Dialekt[mve10] angegeben.Eine in MVEL verfasste Regel zeigt das nachfolgende Beispiel:

Listing 2.1: Beispiel Regel in MVEL1 rule "rule1"

when

3 $cpu: CPU( temp > 80 && voltage > 1.55 )

$cpucooler: Cooler( cpu==$cpu && fanspeed <= 120 )

5 then

$cpucooler.setFanspeed (200);

7 end

Die Regel hangt von den zwei Objekten CPU und Cooler ab. Der deterministische Baum,der fur diese Regel erzeugt wird, besteht aus zwei Pfaden (Abbildung 2.2).Einer behandelt alle Abfragen am Objekt CPU und der Andere Abfragen am ObjektCooler. Die ersten Knoten jedes Zweiges sind vom Typ ObjektTypNode und uberprufendie im WorkingMermory enthaltenden Fakten auf ihr Instanzart. Das bedeutet: Fur unserBeispiel werden alle Objekte kontrolliert, ob sie vom Typ CPU oder vom Typ Coolersind. Wenn die Fakten vom Typ des entsprechenden Zweiges sind, werden diese an dendarauf folgenden Knoten propagiert. Jeder Zweig enthalt fur jede atomare Abfrage, auseiner Regel, einen Knoten vom Typ AlphaNode. Der Pfad fur die Fakten vom Typ CPUbeinhaltet zwei AlphaNodes. Der erste Knoten uberpruft ob die Temperatur großer als80◦C ist. Falls dies zutrifft, wird ein neuer Eintrag in dem AlphaMemory fur das Objekterzeugt. Anschließend wird das Objekt an den nachsten Knoten propagiert. Der nachsteKnoten vom Typ AlphaNode uberpruft, ob die Spannung der CPU großer als 1,55V ist.Im Pfad des Coolers wird abgefragt, ob die Cooler-Instanz zu einer im AlphaMemory

Abbildung 2.2.: Baum fur die im Listing gezeigte Regel

gespeicherten CPU-Instanz gehort. Daher propagiert der LeftInputAdapterNode, aus

17


dem Pfad der CPU das Tupel, bestehend aus Objekt Hashwert und Instanz-ID, an denlinken Eingang des BetaNodes. Wurden alle Bedingungen erfullt, fugt der TerminalNodedie Regel zur Konfliktmenge hinzu.

2.3. Erweiterung des Rete-OO Algorithmus um Fuzzy Logik

Davide Sottara hat in [DS08] eine Moglichkeit vorgestellt den Rete-OO Algorithmusum Fuzzy Logik zu erweitern. Seine Erweiterungen sind in dem Drools-Branch DroolsChance [Sot10b] zu finden. In den nachsten Zeilen wird auf die grundlegende Idee seinerErweiterung eingegangen.Bei der Implementierung von Fuzzy Logik gibt es mehrere gravierende Unterschiede. Beider von Davide Sottara vorgestellten Moglichkeit wird die Unscharfe als ungefahr auf-gefasst. Bei dieser Implementierung kann man sich die Fuzzy-Sets, je nach Abfrage, alsansteigende oder abfallende Flanke vorstellen, wobei der zu prufende Wert als Schwell-wert dient. Bei diesem Verfahren wird die Standard MVEL-Syntax um die Operatoren

”˜“, is und seems erganzt. Auf den beiden Operatoren is und seems wird in den nachstenAbschnitten noch eingegangen. Eine Abfrage, die mit dem ”˜“-Operator anfangt, wirdals unscharfer Wert aufgefasst. Dies bedeutet fur die Temperatur-Regel aus 2.1:

Listing 2.2: Beispiel Regel mit ”˜“-Operator1 rule "rule1"

degree εr3 when

cpu: CPU( temp ~> 80 && voltage ~> 1.55 )

5 cpucooler: Cooler( cpu==cpu && fanspeed ~> 120 )

then

7 cpucooler.setFanspeed (200);

end

Wie durch die vorangegangenen Abschnitte zu erkennen ist, muss bei der Erweite-rung des Rete-OO-Algorithmus bedacht werden, dass es keine scharfen Werte mehr gibt.Hierdurch konnen Auswertungen der Knoten bei ”falsch“ nicht einfach verworfen wer-den. Dies fuhrt zu einem weiteren Problem: ”Was passiert mit nicht erfullten Regeln?“.Um dieses Problem zu losen, gibt es mehrere Strategien:

Niemals verwerfen: Regeln deren Bedingungen nicht erfullt sind, werden trotzdem ge-feuert. Dieses Verhalten generiert allerdings ein Performance Problem.

Kunstliche Schwellwerte: Uber ein Regelargument (degree) kann man einen Schwell-wert setzen, der den Zugehorigkeitswert angibt, der erfullt sein muss, damit eineRegel feuert.

Heuristiken und weiteres: Uber Interfaces ist es moglich eigene Evaluatoren zu imple-mentieren.

18


2.4. Drools Chance

Wie bereits erwahnt ist es moglich eigene Evaluatoren zu erstellen. Diese Evaluatorenmussen sich von der abstrakten Klasse BaseImperfectEvaluator ableiten. Die abstrakteKlasse enthalt eine Vielzahl von unterschiedlichen eval()-Methoden. Das nachste Listingzeigt eine solche Methode. Wie man erkennen kann, gibt diese Methode eine Variabledes Typs IDegree zuruck.

Listing 2.3: Beispiel einer eval()-Methode der abstrakten Klasse BaseImperfectEvaluatorprotected abstract IDegree eval(Object left , Object right , IDegreeFactory factory );

Das Interface IDegree reprasentiert den Zugehorigkeitswert einer Variable, also einenWert im Intervall I:= [0, 1]. Zusatzlich zu der Reprasentation des Intervalls ist es laut[Sot10a] eine Anforderung an IDegree, die Werte True und False annehmen zu konnen.Daher bietet es eine Moglichkeit den Zugehorigkeitswert auf boolean zu casten.Damit die Ruleengine bei der Auswertung einer Regel mit Fuzzylogik auch den ange-passten Evaluator wahlt, muss dieser registriert werden. Das Registrieren eines solchenEvaluators geschieht in zwei Schritten. Zum einem muss eine Definition, die sich vonImperfectEvaluatorDefinition ableitet, erstellt werden. Diese Definition enthalt eine ID(z.B. ”seems“), die angibt auf welche Regeln der Evaluatoroperator angewendet werdensoll. Außerdem enthalt die Definition eine getEvaluator()-Methode, die den Evaluatorzuruckgibt. Zusatzlich muss der Operator an der Klasse Operator registriert werden.Im zweiten Schritt wird der Classname des Standards Operators durch den eigenenClassname ersetzt. Dazu wird beim Erstellen der RuleEngine eine modifizierte Package-BuilderConfiguration ubergeben.Durch diesen Mechanismus war es uns moglich einen Adapter fur das Jefis Projekt zuschreiben. Dieser Adapter erlaubt es die Regeln mit Hilfe der FuzzySets und FuzzyNor-men aus Jefis auszuwerten. Im nachsten Abschnitt wird die Implementierung des Adap-ters beschrieben, wodurch noch einmal verdeutlicht wird, wie man eigene Evaluatorenerstellt und registriert.

2.5. Adapter

Die Abbildung 2.3 gibt einen Uberblick uber die Klassen die genutzt werden um Jefis zuadaptieren. Das zentrale Objekt des Jefis Projektes ist das FuzzySet. FuzzySets verfugenuber das Wissen wie sie miteinander verknupft werden sollen. Das heißt: Welche Ope-ratoren beim And oder Or angewendet werden sollen. Außerdem liefern FuzzySets dieZugehorigkeit zu einer Variable.Hinter jeder linguistischen Variable aus einer Regel steht ein solches Set. Auf diesesFuzzySet muss der Evaluator zugreifen konnen um die Zugehorigkeit zuruckgeben. Furdas folgende Listing 2.4 bedeutet dies, dass der Evaluator auf die beiden FuzzySets mit

”cold“ und ”low“ zugreifen muss. Uber die toString()-Methode des ”right“-Objektes ausder eval()-Methode bekommt man den Namen des Sets geliefert.

19


Abbildung 2.3.: Klassendiagramm des Jefis-Drools-Adapters

Listing 2.4: Beispiel Regel mit Fuzzy-Evaluatoren1 rule "R11"

when

3 $cooler: Cooler($t: temperature is "cold" && $c: fanCurrent is "low" )

then

5 $cooler.setStatus (" green", drools.getConsequenceDegree ());

end

Mit diesen Namen kann man sich an der Klasse FuzzySetRegistry das entsprechende Fuz-zySet geben lassen. Die Registry ist als Singelton realisiert worden. Registriert werdendie FuzzySets automatisch beim Erzeugen eines FuzzySetDecorators. Dieses Vorgehenschließt ein, dass der Name ”cold“, da er zu Identifizierung genutzt wird, eindeutig seinmuss.Damit die Ruleengine den FuzzyEvaluator auch benutzt, wird in der Klasse JefisDrools-Builder der Property Eintrag des entsprechenden Evaluators in der Klasse PackageBuil-derConfiguration angepasst, siehe nachfolgendes Listing 2.5.

Listing 2.5: Ersetzen der Standard Evaluatorenprotected void configurePackageBuilder () {

2 packageBuilder = new PackageBuilder ();

packageBuilderConf = packageBuilder.getPackageBuilderConfiguration ();

4// regis ter some EvaluatorDefinitions . . .

6 packageBuilderConf.setProperty("drools.evaluator.seems",

FuzzySeemsEvaluatorDefinition.class.getName ());8 packageBuilderConf.setProperty("drools.evaluator.is",

IsEvaluatorDefinition.class.getName ());10 }

Die Regel R11 aus dem vorausgegangenen Beispiel besteht aus zwei Pramissen, die durchden &&-Operator verknupft sind. Fur die Berechnung ruft die Ruleengine ein Implemen-

20


tierung von IDegreeFactory auf. Welche Factory gewahlt wird, kann beim Erzeugen einerRuleBase angegeben werden, siehe nachfolgendes Listing:

Listing 2.6: Ubergabe der DegreeFactoryruleBaseConf = new RuleBaseConfiguration ();

2 ruleBaseConf.setProperty(DEGREE_FACTORY_TAG , JefisDegreeFactory.class.getName ());

4 ...

RuleBase ruleBase = RuleBaseFactory.newRuleBase(ruleBaseConf );

Welche Algorithmen die Factory JefisDegreeFactory fur die Operatoren zuruckgibt, wirdin einer Properties-Datei parametrisiert [NW09]. Durch einen Eintrag bestimmt manwelcher Operator mit welcher Klasse verknupft ist. Im folgendem Beispiel 2.7 wird dieFactory so parametrisiert, dass diese als Standardnormoperator eine Instanz der Klasse

”de.lab4inf.fuzzy.norms.FuzzyMinMax“ und als Standardimplikationsoperator eine In-stanz der Klasse ”de.lab4inf.fuzzy.logic.Mamdani“ zuruckgibt.

Listing 2.7: Beispiel der Properties-Datei1 norm.operator.DEFAULT = de.lab4inf.fuzzy.norms.FuzzyMinMax

norm.operator.MinMax = de.lab4inf.fuzzy.norms.FuzzyMinMax

3 .

.

5 .

7 implication.operator.DEFAULT = de.lab4inf.fuzzy.logic.Mamdani

implication.operator.Zadeh = de.lab4inf.fuzzy.logic.Zadeh

9 implication.operator.Goedel = de.lab4inf.fuzzy.logic.Goedel

.

11 .

.

21

Teil III.

Jefis RuleengineAutor: Dennis Lohr, B.Sc.

22

3. Jefis Ruleengine

3.1. Einleitung

Nach einem erfolgreichen Abschluss der ersten Halfte des Masterprojektes, wurde ent-schieden das wir uns in der zweiten Halfte des Masterprojektes das an der Fachhoch-schule Munster entwickelte Jefis erweitern. Damit es mit Jefis nicht nur moglich istFuzzy-Controlling zu betreiben, sondern auch moglich ist Fuzzy-Logic abzubilden. Da-bei sollte man berucksichtigen das Jefis von sich aus keine Ruleengine, sondern einenFuzzy-Controller abbildet. Dieser ist zwar so entwickelt, dass Jefis aus einer XML-Dateidie Regeln dynamisch neu einliest aber dadurch, dass der Controller nur scharfe Werteverarbeiten kann, war er nicht geeignet fur das eigentliche Ziel unseres Masterprojektes.Eines der wichtigsten Eigenschaften einer Ruleengine ist, dass es die Ergebnisse aus einervorherigen Regel, als Eingabe fur eine neue benutzen kann (siehe Vorwartsverkettung1.3.4.1 bzw. Ruckwartsverkettung 1.3.4.2).

Dies wurde bei Jefis daruber gelost, das die Ergebnisse erst defuzzifiziert und anschlie-ßend wieder fuzzifiziert werden. Durch dieses Defuzzifizieren und anschließendem Fuz-zifizieren entstehen Ungenauigkeiten die spatestens nach der Hintereinanderausfuhrungvon mehreren Regeln ein erhebliches Ausmaß annehmen.

3.2. Beispiel in Lab4Jefis

Da Jefis eine gute Moglichkeit liefert die Fuzzysets zu visualisieren wurde eine Beispielan-wendung im Applet FuzzyRuleEngineApplet demonstriert. Bei diesem Applet gibt es vierFuzzysets in der Regelbasis (Food, Service, Tip und Waiter), damit wir eine Hinterein-anderausfuhrung von mehreren Regeln haben gibt es dazu die Regeln:

1. IF service IS good AND food IS delicious THEN tip IS generous

2. IF tip IS generous THEN waiter IS happy

In Abbildung 3.1 ist unter den Fuzzysets Premise: food und Premise: service zu sehen,mit welchen Eingabesets wir in die Regeln hineingegangen sind. Die Eingabe Sets sindauch in den Fuzzysets Service und Food zu sehen, bei service ist dies das gelbe Dreieckwobei die Schnittmenge mit dem Set service:good hier als weiße Flache eingefarbt ist.Beim set food ist das Eingabeset durch das lila Dreieck und die Schnittmenge durch eineturkise Flache gekennzeichnet. Aus diesen beiden Fuzzyset-Schnittmengen ergibt sichjetzt das Fuzzyset Premise: tip das im Ausgabe Set Tip bis zum Minimum der beiden

23

KAPITEL 3. JEFIS RULEENGINE

Abbildung 3.1.: Applet zur Visualisierung der Implikation

Eingabe Sets gefullt ist. Zum Schluss bildet sich aus dem neuen Eingabeset Premise:tipdas neue Ausgabeset Result:waiter.

In dem Applet 3.2 wurde die Regelbasis noch fest in den Javacode eingegeben. Fureine produktive Umgebung kann man dies allerdings nur schwer durchsetzen da, wieim Kapitel 1.3.2 schon beschrieben ist, sich viele Regeln andern. Deshalb haben wirvor der Auswahl einer geeigneten Reprasentation der Regeln gestanden, zur Auswahlkamen dabei die XML-Basierte Sprache von Jefis, die standardisierte FCL 4.1 oder einevollkommen eigene Entwicklung. Aufgrund dessen, dass es sich im Gegensatz zu beidenAlternativen bei FCL um eine standardisierte Sprache fur Fuzzy handelt wurde diesedann auch genommen. Genaueres kann aus dem Kapitel 4.1 entnommen werden.

3.3. Die Lab4Jefis Rule-Engine

Um das Beispiel des Applet 3.1 mit FCL Unterstutzung zu benutzen, benotigen wir eineFCL-Datei. Diese FCL-Datei muss wie im nachfolgenden Kapitel 4.1 beschrieben wirdaufgebaut sein. Fur das Beispiel stellt die FCL-Dateien die Wissensbasis des Systemsdar. Damit die beiden Eingabesets aus dem obigen Beispiel also zur Verfugung stehen,benotigen wir innerhalb des FUNCTION BLOCKs die Elemente aus dem Listing 3.1.

24


Listing 3.1: FCL beschreibung der Fuzzysets service und foodVAR_INPUT

2 service : REAL;

food : REAL;

4 END_VAR

6 FUZZIFY service

TERM poor := (0, 1) (4, 0);

8 TERM good := (1, 0) (4,1) (6,1) (9 ,0);

TERM excellent := (6, 0) (9, 1);

10 END_FUZZIFY

12 FUZZIFY food

TERM rancid := (0, 1) (1, 1) (3,0);

14 TERM delicious := (7,0) (9,1);

END_FUZZIFY

Wobei es fur die Rule-Engine nicht erheblich ist, ob ein Fuzzyify oder Defuzzify Blockbenutzt wird, da wir in der Rule-Engine mit den Ausgabesets der vorherigen Regel weiterarbeiten. Deshalb sollten wir auch fur ”tip“ einen Fuzzyify Block, wie im folgendenListing 3.2 benutzen.

Listing 3.2: FCL beschreibung der Fuzzysets tip und waiter1 VAR_OUTPUT

tip : REAL;

3 waiter : REAL;

END_VAR

5FUZZIFY tip

7 TERM cheap := (0,0) (5,1) (10 ,0);

TERM average := (10 ,0) (15,1) (20 ,0);

9 TERM generous := (20 ,0) (25 ,1) (30 ,0);

END_FUZZIFY

11DEFUZZIFY waiter

13 TERM sad := (-1.1,0) (-1,1) (0,1) (3 ,0);

TERM normal := (2,0) (4,1) (5,1) (7 ,0);

15 TERM happy := (6,0) (9,1) (9.5 ,1) (9.6 ,0);

END_DEFUZZIFY

Wie beim Fuzzyset waiter bzw. food zu sehen ist, konnen nicht nur Dreiecke benutztwerden, sondern es ist auch moglich Senken, Trapeze oder Polygone zu benutzen. Da-durch ist der Freiheitsgrad beim Erstellen der Fuzzysets groß, was allerdings bei denPolygonen, wenn sehr viele Regeln benutzt werden zu Performance Einbußen fuhrt. Da-mit die Wissensbasis fur das Beispiel aus dem Applet aber komplett ist, wird zusatzlichzu den Fuzzysets auch der RULEBLOCK mit den Regeln benotigt. Die beiden Regeln ausdem Beispiel konnen hierfur einfach wie in Listing 3.3 eingegeben werden oder zusatzlichmit der Norm und der Implikation versehen werden wie in Listing 3.4.

Listing 3.3: FCL beschreibung der Regeln ohne Norm und ImplikationRULEBLOCK No1

2 RULE 1 : IF service IS good AND food IS delicious THEN tip IS generous;

RULE 2 : IF tip IS generous THEN waiter IS happy;

4 END_RULEBLOCK

Listing 3.4: FCL beschreibung der Regeln mit Norm und ImplikationRULEBLOCK No1

2 AND : MIN;

ACCU: MAX;

4 RULE 1 : IF service IS good AND food IS delicious THEN tip IS generous;

RULE 2 : IF tip IS generous THEN waiter IS happy;

6 END_RULEBLOCK

Damit sind alle Teile der FCL-Datei komplett. Diese kann auch im Anhang zusam-mengefasst unter Listing 6.1 betrachtet werden. Damit das Wissen, das in der FCL-Datei

25


enthalten ist, in der Rule-Engine benutzten werden kann, wird ein FCLRuleEngineBuil-der benotigt. Uber diesen kann mit der Methode buildRuleEngine dann die Rule-Enginemit der FCL-Datei erzeugt werden. Damit die Rule-Engine jetzt aber auch eine Regelausfuhren kann, benotigt sie eine Faktenbasis. Als Input fur die Faktenbasis hatte dasBeispiel aus dem Applet fur beide Fuzzysets, service und food, ein normales Dreieck.Dieses erzeugen wir uber den Konstruktor des FuzzyTriangle und setzten den Namendes Fuzzysets, auf den es angewendet werden soll. Danach werden die einzelnen Sets zuder Premise hinzugefugt. Das Listing 3.5 enthalt alle dafur notwendigen Elemente.

Listing 3.5: Java Code zum erstellen der Beispiel PremiseHashMap <String , FuzzySet > premises;

2 FuzzySet set;

premises = new HashMap <String , FuzzySet >();

4 // Serviceset = new FuzzyTriangle (3, 2);

6 set.setName("service");

premises.put(set.getName(), set);

8// Food

10 set = new FuzzyTriangle (7, 3);

set.setName("food");

12 premises.put(set.getName(), set);

Wenn in der FCL-Datei nicht die Implikation und die Norm gewahlt wurden, mussendiese jetzt gesetzt werden. Die dafur notwendigen Funktionen sind im Listing 3.6 ent-halten. Fur diese stellt Jefis eine Vielzahl von verschiedenen Normen und Implikationenzur Verfugung.

Listing 3.6: Java Code zum setzen der Implikation und der NormruleEngine.setImplicationType("Mamdani");

2 ruleEngine.setNorm(new FuzzyMinMax ());

Nachdem der Rule-Engine nun alle Details bekannt sind, die notwendig sind, um dasBeispiel aus dem Applet darzustellen, konnen die Faktenbasis und die Wissensbasis uberdie Methode conclusion zusammengefuhrt werden. Dabei wird eine Liste mit Fuzzysetszuruckgegeben, bei der beachtet werden muss das diese keine bestimmte Reihenfolgebesitzen, sondern uber ihren Namen identifiziert werden konnen.

26

Teil IV.

FCL und ANTLRAutor: Thomas Beermann, B.Sc.

27

4. FCL und ANTLR

4.1. FCL

4.1.1. Einleitung

Die Fuzzy Control Language oder auch FCL ist eine von der International Electrotechni-cal Commission (IEC 61131-7) standardisierte, domanenspezifische Sprache. Es hat nurSprachelemente die direkt mit Fuzzy Logik zusammenhangen, wie die Deklaration vonFuzzy Sets und Regeln, aber nicht einmal so grundlegende Konstrukte wie Schleifen. Ausdem Grund ist es auch nicht moglich ganze Programme in FCL zu schreiben sondernnur die Teile davon, die die Fuzzy Regelmaschine beschreiben. Der Standard ist nichtfrei und muss erworben werden. Allerdings gibt es einen Entwurf von 1997 der sich nichtentscheidend von dem finalen Standard unterscheidet und frei verfugbar ist unter [iec10].Dieser Entwurf wurde in diesem Projekt verwendet.

4.1.2. Beispiel

Im Folgenden wird die Syntax von FCL genauer erklart. Am Besten kann man dies aneinem einfachen Beispiel erklaren. Die in diesem FCL Codebeispiel beschriebene RegelMaschine berechnet die Glucklichkeit eines Kellers anhand des Trinkgelds, welches erwiederum bekommt abhangig von der Qualitat des Essens und des Services.FUNCTION_BLOCK tipper // Anfang eines neuen Block. Es konnen mehrere in einer Datei definiert sein.

2VAR_INPUT // Definition der Eingangsvariablen

4 service : REAL;

food : REAL;

6 tip : REAL;

END_VAR

8VAR_OUTPUT // Definition der Ausgangsvariablen

10 waiter : REAL;

END_VAR

12FUZZIFY service // Festlegung der Sets fur den Eingang ’service ’

14 TERM poor := (0, 1) (4, 0) ;

TERM good := (1, 0) (4,1) (6,1) (9 ,0);

16 TERM excellent := (6, 0) (9, 1);

END_FUZZIFY

18FUZZIFY food // Festlegung der Sets fur den Eingang ’food ’

20 TERM rancid := (0, 1) (1, 1) (3,0) ;

TERM delicious := (7,0) (9,1);

22 END_FUZZIFY

24 FUZZIFY tip // Festlegung der Sets fur den Eingang/Ausgang ’tip ’

TERM cheap := (0,0) (5,1) (10 ,0);

26 TERM average := (10 ,0) (15,1) (20 ,0);

TERM generous := (20 ,0) (25 ,1) (30 ,0);

28 END_FUZZIFY

30 DEFUZZIFY waiter // Festlegung der Sets fur den Ausgang waiter

TERM sad := (0,0) (5,1) (10,0)

32 TERM normal := (10,0) (15,1) (20,0)

TERM happy := (20,0) (25,1) (30 ,0)

28

KAPITEL 4. FCL UND ANTLR

34 END_DEFUZZIFY

36 RULEBLOCK service_food_tip

AND : MIN; // Angabe der Norm. ’MIN ’ fur ’AND ’ impliziert auch ’MAX ’ fur ’OR ’

38 ACCU : MAX; // Angabe der Norm fur die Zusammenfassung der Ergebnisse.

ACT : MIN; // Angabe der Norm fur die Aktivierung der Regeln.

40RULE 1 : IF service IS poor OR food is rancid THEN tip IS cheap;

42 RULE 2 : IF service IS good THEN tip IS average;

RULE 3 : IF service IS excellent AND food IS delicious THEN tip is generous;

44RULEBLOCK tip_waiter

46 AND : BOUNDED;

ACCU : MAX;

48 ACT : PROD;

50 RULE 4 : IF tip IS cheap THEN waiter IS sad;

RULE 5 : IF tip IS average THEN waiter IS normal;

52 RULE 6 : IF tip IS generous THEN waiter IS happy;

END_RULEBLOCK

54END_FUNCTION_BLOCK

FCL wurde als Sprache fur Fuzzy Control entwickelt, was man auch direkt bemerkt.Eine FCL-Datei kann aus mehreren FUNCTION BLOCKs aufgebaut sein. Diese haben wiereale Bausteine einen oder mehrere Ein-und Ausgange. Dieses Beispiel besteht nur ausdem FUNCTION BLOCK tipper. Die Eingaben und Ausgaben werden am Anfang dekla-riert in den Blocken beginnend mit VAR INPUT bzw. VAR OUTPUT. Bei einem normalenFuzzy Control Block werden die Eingange immer fuzzifiziert und die Ausgange immerdefuzzifiert, so dass man die Variablen immer als Input oder Output deklarieren muss.Bei der Rule Engine aus diesem Projekt mussen die Eingange und Ausgange aber nichtunbedingt fuzzifiert und defuzzifiziert werden. Zu einen kann man auch mit unscharfenWerten als Eingang reingehen, zum anderen konnen auch unscharfe Werte als Ausgabeherauskommen. Aus diesem Grund konnen Regeln auch verkettet werden ohne jeweilsdie Eingange oder Ausgange fuzzifizieren bzw. defuzzifieren zu mussen. Daraus folgt,dass man die Variablen nicht immer unbedingt als Input oder Output deklarieren kann.Bei service und food ist es offensichtlich, da diese nur als Eingabe verwendet werdenim Regelblock service food tip benutzt werden. Ebenso verhalt es sich mit waiternur eben als Ausgabe im zweiten Regelblock. Bei tip ist das nicht mehr so eindeutig.tip wird sowohl im 1. als auch im 2. Regelblock verwendet sowohl als Eingabe als auchals Ausgabe. Ist das der Fall wird eine Variable als Eingabe deklariert.

Als nachstes folgt die Angabe der Partitionen und Sets fur die einzelnen Variablen.Dies geschieht in dem FUZZIFY bzw. DEFUZZIFY Block. Fur jede Variable wird ein eigenerBlock angelegt und in diesen Blocken die Sets definiert. Jedes Set wird durch TERMgefolgt von dem Namen eingeleitet. Es gibt dann verschiedene Moglichkeiten ein Set zudefinieren. In diesem Beispiel werden einfach verschiedene Referenzpunkte gewahlt, diein den Klammern angegeben werden. Der erste Wert ist die Eingabe und der Zweitedie Zugehorigkeit zum Set. Zwei Punkte mussen mindestens angegeben werden. Alleweiteren Werte werden dann daraus berechnet.

Nachdem die Eingabe-und Ausgabewerte angegeben und die dazugehorigen Sets de-finiert wurden gibt man im RULEBLOCK die Regeln an. Bevor die eigentlichen Regelnbeginnen, kann man die Rule Engine noch mit 3 verschiedenen Optionen parametrisie-ren. Zunachst ist da die Norm. Hier reicht es entweder die AND oder OR Norm anzugebenda die jeweils andere implizit darauf folgt. Dann gibt es noch die Akkumulationsnorm,

29


die angibt, mit welcher Norm die Ergebnis verbunden werden. Als Drittes gibt es nochdie Aktivierungsnorm, die angibt, welche Norm genutzt wird um herauszufinden welcheRegeln gefeuert werden mussen. Alle drei Optionen sind optional und haben jeweils dieMIN bzw. MAX Norm als Voreinstellung. Danach folgen die Regeln. Dies konnen beliebigviele sein eingeleitet jeweils durch RULE gefolgt von einer Nummer. Die Regel an sichwird durch einfache IF/THEN Konstrukte definiert. Die einzelnen Bedingungen konnendabei beliebig mit AND oder OR verknuft werden.

Mit diesen einfuhrenden Beispiel kann der grundlegende Aufbau von FCL schon rechtgut verstanden werden. Es folgt nun die genaue Beschreibung der einzelnen Blocke.

4.1.3. Beschreibung

4.1.3.1. VAR INPUT / VAR OUTPUT

• Beide Blocke konnen beliebig viele mussen aber mindestens eine Variablendekla-ration enthalten getrennt durch ein Semikolon.

• Eine Variablendeklaration besteht dabei immer aus dem Namen und dem Daten-typen getrennt durch einen Doppelpunkt abgeschlossen durch ein Semikolon.

• Als Datentyp kann nur REAL gewahlt werden.

• Variablen die sowohl Eingabe als auch Ausgabe fur unterschiedliche Regeln sindwerden als Eingabe deklariert.

4.1.3.2. FUZZIFY / DEFUZZIFY

• Fur jede Eingabevariable wird ein FUZZIFY Block angegeben und fur jede Ausga-bevariable ein DEFUZZIFY Block.

• Es konnen beliebig viele Sets getrennt durch ein Semikolon angeben werden.

• Ein Set wird deklariert durch einen Namen gefolgt von := und der Angabe derMembershipfunktion. Es gibt:

1. Polygon: Hier werden einzelne Punkte angegeben. Alle weiteren Punkte da-zwischen werden berechnet.

2. Trapez: Angegeben durch TRAPE gefolgt von 4 x-Werten, die von links nachrechts das linke Minimum, das linke Maximum, das rechte Maximum und daslinke Minimum angeben.

3. Dreieck: Angegeben durch TRIAN gefolgt von 3 x-Werten, die von links nachrechts das linke Minimum, das Maximum und das rechte Minimum angeben.

4. Singleton: Angegeben durch einen einfachen x-Wert.

• Der DEFUZZIFY Block hat zusatzlich noch die Option fur die Defuzzifizierungsme-thode (METHOD). Hier gibt es:

30


1. COG: Centre of Gravity.

2. LM: Left Most Maximum.

3. RM: Right Most Maximum.

4.1.3.3. RULEBLOCK

• Ein FUNCTION BLOCK kann beliebig viele RULEBLOCKs haben.

• Ein RULEBLOCK besteht immer aus drei optionalen Parametern und den Regelnselbst.

• Der erste Parameter ist die Operatordefinition (AND / OR). Hier wird entwederdie Norm fur AND oder OR angegeben. Die jeweils dazugehorige andere Norm wirddadurch implizit mit angegeben. Fur AND gibt es:

1. MIN: Min(µ1(x), µ2(x))

2. PROD: µ1(x) ∗ µ2(x)

3. BDIF: Max(0, µ1(x) + µ2(x)− 1)

Fur OR sind es:

1. MAX: Max(µ1(x), µ2(x))

2. ASUM: µ1(x) + µ2(x)− µ1(x) ∗ µ2(x)

3. BSUM: Min(1, µ1(x) + µ2(x))

Wenn keine Angabe fur AND oder OR gemacht wird wird MIN bzw. MAX genommen.

• Der zweite Parameter ist Aktivationsmethode (ACT). Sie gibt an welche Normgenommen wird um herauszufinden welche Regeln uberhaupt gefeuert werdenmussen. Hier gibt es:

1. PROD: µ1(x) ∗ µ2(x)

2. MIN: Min(µ1(x), µ2(x))

Wenn keine Angabe gemacht wird, wird MIN verwendet.

• Der letzte Parameter ist der Akkumulationoperator (ACCU). Dieser gibt die Norman die zum Zusammenfugen der Ergebnisse genutzt wird. Es gibt:

1. MAX: Max(µ1(x), µ2(x))

2. BSUM: Min(1, µ1(x) + µ2(x))

Wenn keine Angabe gemacht wird, wird MAX verwendet.

• Danach folgen die Regeln. Davon kann es beliebig viele geben. Eine Regel be-ginnt immer mit dem Schlusselwort RULE und einer ID, die eine beliebige Zei-chenkette beginnen mit einem Buchstaben sein kann, und endet mit einem Se-mikolon. Dazwischen kommt dann die eigentliche Regel. Diese besteht aus einemIF...THEN...(WITH) Konstrukt. Dabei gibt es drei Abschnitte

31


– IF: Besteht aus einer oder mehreren Bedingungen verknupft durch AND oderOR. Eine Bedingung besteht dabei aus Input IS Set. Input ist der Nameeiner vorher definierten Eingabevariablen und Set ist der Name eines imFUZZIFY Teil fur diese Variable definierten Sets.

– THEN: Besteht aus einer Folgerung bestehend aus Output IS Set.

– WITH: Der WITH Teil ist optional gibt einer Folgerung eine Gewichtung. Essind Werte zwischen 0.0 und 1.0 erlaubt. Diese beeinflussen das Ausgabesetindem die Zugehorigkeit um den angegebenen Faktor verringert wird. Wennkein Wert angeben ist wird 1.0 verwendet.

4.2. ANTLR

4.2.1. Einleitung

Nachdem FCL als Sprache fur die Angabe der Sets und Regeln bestimmt wurde mussteentschieden werden, wie man diese in Java einliest und in Jefis-Objekte umwandelt. EinMoglichkeit ware es selbst die einzelnen Zeichen aus der Datei auszulesen und einenAutomaten zu entwickeln, der die Zeichenfolge auf Korrektheit uberpruft und dann dieObjekte erstellt. Zum Einen ist dies aber sehr aufwendig zu machen zum Anderen wirdes dadurch schwer wartbar und auch erweiterbar. Dieser Umstand fuhrt zu ANotherTool for Language Recognition, kurz ANTLR. Ein großer Vorteil ist es, dass es schoneine Grammatikdatei von ANTLR fur FCL gibt 1. Lexer und Parser werden aus dieserGrammatikdatei automatisch erzeugt und Anderungen konnen einfach in der Grammatikvorgenommen. Der durch den Parser erzeugte Syntaxbaum kann dann mit einem auchvon ANTLR erzeugten Tree Walker durchlaufen werden, so dass dann die Jefis-Objektedaraus erstellt werden konnen. Im Folgenden wird erklart, wie eine solche Grammatikdefiniert wird und wie der Tree Walker den Syntaxbaum verarbeiten kann.

4.2.2. Lexer/Parser

Die Hauptaufgabe des Lexer und des Parsers ist es eine eingegebene Datei auf ihresyntaktische Korrektheit zu uberprufen. Der Lexer zerlegt dabei den Strom an Zeichen infur den Parser verstandliche Tokens. Wenn diese Tokens an den Parser ubergeben wordensind uberpruft der dieser, ob die Zeichenfolge einem gultigen Programm entspricht. Istdas der Fall wird ein Baum erstellt mithilfe dessen man spater den Code erzeugen kann.Die Erstellung des Lexer und des Parsers wird komplett von ANTLR ubernommen.Das einzige was ANTLR dafur braucht ist eine .g Datei (Grammatik Datei). In dieserDatei wird eine kontextfreie Grammatik in EBNF angegeben, die die gewunschte Sprachebeschreibt. An einem kleinen Beispiel soll diese Grammatik jetzt beschrieben werden.Die komplette Grammatik fur FCL kann im Anhang gefunden werden.

1Entwickelt von Pablo Cingolani im Projekt JFuzzyLogic

32


4.2.3. Beispiel

In diesem Beispiel wird der Teil von FCL.g erklart, der die VAR INPUT/VAR OUTPUT Blockbestimmt.

1 grammar FCL;

......

3 FUNCTION_BLOCK : (’f’|’F’)(’u’|’U’)(’n’|’N’)(’c’|’C’)(’t’|’T’)(’i’|’I’)(’o’|’O’)(’n’|’N’)’_’(’b’|’B’)

(’l’|’L’)(’o’|’O’)(’c’|’C’)(’k’|’K’);

5 END_FUNCTION_BLOCK : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’f’|’F’)(’u’|’U’)(’n’|’N’)(’c’|’C’)(’t’|’T’)

(’i’|’I’)(’o’|’O’)(’n’|’N’)’_’(’b’|’B’)(’l’|’L’)(’o’|’O’)(’c’|’C’)(’k’|’K’);

7TYPE_REAL : (’r’|’R’)(’e’|’E’)(’a’|’A’)(’l’|’L’);

9 VAR_INPUT : (’v’|’V’)(’a’|’A’)(’r’|’R’)’_’(’i’|’I’)(’n’|’N’)(’p’|’P’)(’u’|’U’)(’t’|’T’);

VAR_OUTPUT : (’v’|’V’)(’a’|’A’)(’r’|’R’)’_’(’o’|’O’)(’u’|’U’)(’t’|’T’)(’p’|’P’)(’u’|’U’)(’t’|’T’);

11 END_VAR : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’v’|’V’)(’a’|’A’)(’r’|’R’);

13 ......

15 // -----------------------------------------------------------------------------

// Lexer

17 // -----------------------------------------------------------------------------

......

19 COLON : ’:’;

SEMICOLON : ’;’ ;

21 ......

// A DIGIT

23 fragment DIGIT : ’0’..’9’ ;

25 // A letter

fragment LETTER: LOWER | UPPER;

27 fragment LOWER: ’a’..’z’;

fragment UPPER: ’A’..’Z’;

29// Letter or digit

31 fragment ALPHANUM : LETTER | DIGIT;

......

33 // An identifier.

ID : LETTER (ALPHANUM | ’_’)*;

35 ......

37 // -----------------------------------------------------------------------------

// Parser

39 // -----------------------------------------------------------------------------

41 main : f=fcl -> ^(FCL $f);

fcl : (function_block )+;

43// Function block

45 function_block : FUNCTION_BLOCK^ (ID)? (declaration )* END_FUNCTION_BLOCK !;

declaration : var_input | var_output | fuzzify_block | defuzzify_block | rule_block;

47// Variables input and output

49 var_input : VAR_INPUT^ (var_def )+ END_VAR !;

var_output : VAR_OUTPUT^ (var_def )+ END_VAR !;

51 var_def : ID^ COLON! data_type SEMICOLON !;

53 ......

55 data_type : TYPE_REAL;

Zu Beginn einer .g Datei kommt die Deklaration der Schlusselworter. In diesem Aus-schnitt ist es z.B. TYPE REAL, welches fur die Zeichenkette REAL steht. Die Groß- undKleinschreibung der einzelnen Buchstaben ist dabei egal.

Weiter folgen dann die Angaben fur den Lexer, d.h. wichtige Zeichen, wie z.B. derDoppelpunkt oder das Semikolon.

Danach kommt dann der Teil fur den Parser. Hier werden einfache Ersetzungsregelnaufgestellt in denen auch der Baum erstellt wird. Der oberste Knoten eines FCL Baumesist immer die Zeichenfolge FCL. Die Kinder davon sind die Baume fur die einzelnenFunktionsblocke. Um dies zu realisieren gibt es die beiden Regeln main und fcl. mainwird einfach nur durch fcl ersetzt. Durch f=fcl wird eine Variable f erzeugt, die imzweiten Teil der Regeln benutzt werden kann. Der zweite Teil erzeugt den eigentlichen

33


Baum. Durch das ^ gefolgt von den Klammern wird ein neuer Unterbaum erzeugt, wobeidas erste Token, hier FCL, der Knoten ist und die darauf folgenden Token die Blatter, hierdie vorher erzeugte Variable f. $f wird dann durch die von fcl erzeugten Unterbaumeersetzt.

Die Regel fcl ist recht einfach. Durch das + gibt sie an, das es durch mehrere abermindestens einen function block ersetzt werden muss. Hier wird kein neuer Unterbaumerzeugt.

Das folgt in function block. Ein Funktionsblock muss immer mit FUNCTION BLOCKanfangen und mit END FUNCTION BLOCK enden. Dazwischen folgt eine optionale ID ange-geben durch das ? und null oder mehrere declaration angegeben durch das *. Durchdas ^ wird wieder der neue Unterbaum eingeleitet mit dem Knoten FUNCTION BLOCK.Das erste Blatt ist dann die ID. Die weitere Blatter sind die declaration, falls vorhan-den. Das ! gibt an, dass END FUNCTION BLOCK verworfen und nicht mit in den Baumubernommen wird.

Eine declaration wiederum wird durch eine der 5 Optionen ersetzt. Fur das Beispielsind nur var input und var output interessant.var input und var output sind recht ahnlich und unterscheiden sich nur durch die

Namen. Auch hier wird wieder ein neuer Unterbaum fur jeden Block angelegt. DerKnoten ist wieder VAR INPUT oder VAR OUTPUT und die Blatter sind eine oder mehrerevar def. END VAR wird wieder verworfen.

Eine der letzten Regeln fur die Variablen Blocke ist var def. Solch eine var defbesteht immer aus einer ID gefolgt von einem Doppelpunkt, dem data type und abge-schlossen mit einem Semikolon. Der Unterbaum der daraus erzeugt wird besteht einfachnur aus der ID und dem Datentypen als Blatt.

Zuletzt kommt noch data type. Hier ist nur TYPE REAL zugelassen.

Zum verdeutlichen wird an dem folgenden kurzen Codebeispiel gezeigt, welcher Baumdaraus erzeugt wird.

1 FUNCTION_BLOCK tipper

3 VAR_INPUT

service : REAL;

5 food : REAL;

END_VAR

7VAR_OUTPUT

9 tip : REAL;

END_VAR

11......


Aus der ersten Regel main wird zu Beginn der Knoten FCL erzeugt an dem spater derrestliche Baum hangt.

Die ersten gefunden Token sind FUNCTION BLOCK und tipper. Zuerst wird dadurchdie Regeln fcl behandelt, die dann wieder zu function block fuhrt. In dieser Regelnwird ein neuer Baum angelegt mit dem Knoten FUNCTION BLOCK und zunachst tipperals einziges Kind. Dieser Baum wird als Kind an den Knoten FCL angehangt.

Weiter geht es mit declaration. Davon kann es beliebig viele geben. In diesem Beispielsind es genau zwei. Einmal ein var input und ein var output. Mit der Regel var input

34


wird aus aus dem ersten Block zunachst ein Knoten VAR INPUT erzeugt, der an demKnoten FUNCTION BLOCK dran gehangen wird. An den neuen Knoten werden wiederummit der Regel var def zwei neue Knoten dran gehangen. Jeweils einer fur service undeiner fur food. Jeder dieser Knoten bekommt noch den Datentypen, hier TYPE REAL an-gehangt. Das Gleiche passiert noch fur var output. Hier wird der Knoten VAR OUTPUT er-zeugt und der Knoten tip angehangt, der wiederum den Knoten TYPE REAL dranhangenhat. Auch VAR OUTPUT kommt an FUNCTION BLOCK und er Baum ist damit vollstandig.

Der gesamte Baum ist auch in Abbildung 4.1 abgebildet.

Abbildung 4.1.: Der erzeugte Beispielbaum.

35


4.2.4. Benutzung in Java

Wenn der Lexer und Parser in der .g Datei angegeben wurden muss dieser nur noch vonANTLR erzeugt werden, was komplett automatisch geschieht. Danach konnen beide ineinem Java Programm benutzt werden.

Es gibt verschiedene Moglichkeiten um mit ANTLR den Lexer/Parser zu erzeugen.Die erste ware, das im ANTLR mitgelieferte Tool zu benutzen, dem man einfach die .gDatei ubergibt und das dann die beiden Klassen fur den Lexer und den Parser erzeugtund in .java Dateien ablegt.

Die andere in dem Projekt benutzte Moglichkeit ist es das Maven Plugin zu verwenden.Man kann ein Goal erstellen, das automatisch die Klassen erzeugt. Dazu muss man nurin der pom.xml das Quellverzeichnis und das Ausgabeverzeichnis angeben und dann dasGoal ausfuhren.<plugin >

2 <groupId >org.antlr </groupId >

<artifactId >antlr3 -maven -plugin </artifactId >

4 <version >3.1.1</version >

<configuration >

6 <sourceDirectory >src/main/resources </sourceDirectory >

<outputDirectory >gen</outputDirectory >

8 </configuration >

<executions >

10 <execution >

<goals>

12 <goal>antlr</goal>

</goals>

14 </execution >

</executions >

16 </plugin >

Die erzeugten Klassen kann man dann in dem Projekt folgendermaßen benutzen:......

2 String sourcefile = ‘‘test.fcl’’

FclLexer lexer = new FclLexer(new ANTLRReaderStream(new FileReader(sourceFile )));

4 FclParser parser = new FclParser(new CommonTokenStream(lexer ));

FclParser.main_return root = parser.main ();

6 Tree parsingTree = ((Tree) root.getTree ());

......

Der Lexer bekommt einen ANTLRReaderStream der die Quelldatei geoffnet hat. DerParser bekommt dann einen CommonTokenStream vom Lexer. Am dem Parser konnendann die Regeln aufgerufen werden, die vorher in der .g Datei angelegt wurden. Daman hier die ganze Datei parsen will fangt man mit der ersten Regel main an. Von derRuckgabe des Aufrufs bekommt man den dann einen Tree geliefert den man weiter mitdem Treewalker verwenden kann.

4.2.5. Treewalker

Mit dem erhaltenen Baum konnte man direkt in Java weiterarbeiten. Man kann jeweilsdie Kinder als eigene Baume bekommen und so den kompletten Baum durchlaufen undauswerten. Allerdings gibt es bei ANTLR eine viel angenehmere Losung, den Treewal-ker. Ein Treewalker wird wie der Lexer/Parser in einer .g Datei mit der selben Syntaxangegeben. Die einzelnen Regeln sind fast identisch. Nur wird hier nicht die FCL Dateigeparst sondern der Baum. In jeder Regel kann man Java Code angeben und die Werteaus den Knoten im Java Code verwenden, so dass man direkt an den gewunschten Stellendie passenden Aktionen vornehmen kann.

36


4.2.6. Beispiel

In diesem Beispiel wird ein Treewalker vorgestellt der den Baum aus dem Beispiel zu-vor parst und die Eingabe und Ausgabe Variablen und deren Datentyp einfach uberSystem.out ausgibt. Der richtige Treewalker aus dem Projekt gibt die die einzelnenWerte naturlich nicht nur einfach aus sondern erzeugt damit die RuleEngine. Der Quell-code dafur befindet sich im Anhang.

1@members {

3 private String varType = null;

private String varName = null;

5 }

7 main : ^(FCL fcl);

fcl : (function_block )+;

9// Function block

11 function_block : ^( FUNCTION_BLOCK (ID)? (declaration )*);

declaration : var_input | var_output | fuzzify_block | defuzzify_block | rule_block;

13// Variables input and output

15 var_input : ^( VAR_INPUT (var_def )*) {System.out.println(‘‘Eingabevariablen :’’);

System.out.println ("Name: " + varName + ", Type: " + varType );};

17 var_output : ^( VAR_OUTPUT (var_def )){ System.out.println(‘‘Ausgabevariablen :’’);

System.out.println ("Name: " + varName + ", Type: " + var\Ttype );};

19 var_def : ^(ID data_type ) {varName = $ID.text};

......

21 data_type : TYPE_REAL {varType = ‘‘REAL ’’};

Aus der .g Datei wird spater eine Java Klasse erzeugt. Deshalb ist es auch moglich sta-tische Java-Blocke darin zu definieren, die 1 zu 1 in die Java Klasse ubernommen werden.Zum einen gibt es den @header Block indem das Package und die Includes angegebenwerden konnen und zum anderen den @members indem man sowohl Klassenvariablen alsauch Funktionen deklarieren kann. In diesen Beispiel werden die beiden String varTypeund varName deklariert die spater noch Verwendung finden.

Danach fangen wieder die Regeln an. Um das Ganze ubersichtlich zu gestalten werdenhier wieder die gleichen Namen wie bei dem Parser gewahlt. Die Regeln vom Parserkonnen als Grundlage gewahlt werden und mussen nur leicht angepasst werden um denBaum zu parsen. Das Zeichen ^ gibt auch hier wieder an, dass ein neuer Unterbaumbeginnt. In den Klammern ist dann angegeben, wie dieser auszusehen hat um gematchtzu werden. In diesem Beispiel heißt das, dass der Baum mit dem Knoten FCL begin-nen muss. Die Kinder werden aus der Regel fcl abgeleitet und die besteht wiederumaus einem oder mehreren function block. Das geht dann so weiter wie vorher. Einfunction block besteht wieder aus dem Knoten FUNCTION BLOCK und den Kindern IDund declaration. Interessant wird es ab der Regel var input. Hier werden die Ein-gabevariablen mit Namen und Typ ausgegeben. Jetzt konnte man annehmen, dass diebeiden Variablen varName und varType noch null sind, wenn man das erste Mal dorthinkommt und die Ausgabe wurde nicht funktionieren. Das ist aber nicht der Fall. DerBaum wird von unten nach oben durchlaufen. D.h. es wird mit data type begonnen,wo die Variable varType gesetzt wird. Danach geht es in die Regel var def. Hier wirdvarName gesetzt. Dafur wird der Wert von ID ausgelesen. Dies kann man in Java Codeeinfach machen, indem man ein $ vor ID setzt und dann die Variable text ausliest. Erstdann kommt man in die Regel var input. Hier greift man dann einfach auf die vorhergesetzten Strings zu und gibt diese einfach uber System.out aus.

37

Teil V.

Anhang

38

5. ANTLR

A. Fcl.g

1 grammar Fcl;

3 options {

// We’re going to output an AST.

5 output = AST;

}

7// Tokens (reserved words)

9 tokens {

POINT;

11 FCL;

}

13@lexer :: header {

15 package de.lab4inf.fcl;

}

17@header {


}

22ABS : (’a’|’A’)(’b’|’B’)(’s’|’S’);

24 ACCU : (’a’|’A’)(’c’|’C’)(’c’|’C’)(’u’|’U’);

ACT : (’a’|’A’)(’c’|’C’)(’t’|’T’);

26 AND : (’a’|’A’)(’n’|’N’)(’d’|’D’);

ASUM : (’a’|’A’)(’s’|’S’)(’u’|’U’)(’m’|’M’);

28 BDIF : (’b’|’B’)(’d’|’D’)(’i’|’I’)(’f’|’F’);

BSUM : (’b’|’B’)(’s’|’S’)(’u’|’U’)(’m’|’M’);

30 COA : (’c’|’C’)(’o’|’O’)(’a’|’A’);

COSINE : (’c’|’C’)(’o’|’O’)(’s’|’S’)(’i’|’I’)(’n’|’N’)(’e’|’E’);

32 COG : (’c’|’C’)(’o’|’O’)(’g’|’G’);

COGS : (’c’|’C’)(’o’|’O’)(’g’|’G’)(’s’|’S’);

34 COGF : (’c’|’C’)(’o’|’O’)(’g’|’G’)(’f’|’F’);

COS : (’c’|’C’)(’o’|’O’)(’s’|’S’);

36 DEFAULT : (’d’|’D’)(’e’|’E’)(’f’|’F’)(’a’|’A’)(’u’|’U’)(’l’|’L’)(’t’|’T’);

DEFUZZIFY : (’d’|’D’)(’e’|’E’)(’f’|’F’)(’u’|’U’)(’z’|’Z’)(’z’|’Z’)(’i’|’I’)(’f’|’F’)(’y’|’Y’);

38 DSIGM : (’d’|’D’)(’s’|’S’)(’i’|’I’)(’g’|’G’)(’m’|’M’);

END_DEFUZZIFY : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’d’|’D’)(’e’|’E’)(’f’|’F’)(’u’|’U’)(’z’|’Z’)

40 (’z’|’Z’)(’i’|’I’)(’f’|’F’)(’y’|’Y’);

END_FUNCTION_BLOCK : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’f’|’F’)(’u’|’U’)(’n’|’N’)(’c’|’C’)

42 (’t’|’T’)(’i’|’I’)(’o’|’O’)(’n’|’N’)’_’(’b’|’B’)(’l’|’L’)(’o’|’O’)(’c’|’C’)(’k’|’K’);

END_FUZZIFY : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’f’|’F’)(’u’|’U’)(’z’|’Z’)(’z’|’Z’)(’i’|’I’)

44 (’f’|’F’)(’y’|’Y’);

END_RULEBLOCK : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’r’|’R’)(’u’|’U’)(’l’|’L’)(’e’|’E’)(’b’|’B’)

46 (’l’|’L’)(’o’|’O’)(’c’|’C’)(’k’|’K’);

END_VAR : (’e’|’E’)(’n’|’N’)(’d’|’D’)’_’(’v’|’V’)(’a’|’A’)(’r’|’R’);

48 EXP : (’e’|’E’)(’x’|’X’)(’p’|’P’);

FUNCTION : (’f’|’F’)(’u’|’U’)(’n’|’N’)(’c’|’C’)(’t’|’T’)(’i’|’I’)(’o’|’O’)(’n’|’N’);

50 GAUSS : (’g’|’G’)(’a’|’A’)(’u’|’U’)(’s’|’S’)(’s’|’S’);

GBELL : (’g’|’G’)(’b’|’B’)(’e’|’E’)(’l’|’L’)(’l’|’L’);

52 FUNCTION_BLOCK : (’f’|’F’)(’u’|’U’)(’n’|’N’)(’c’|’C’)(’t’|’T’)(’i’|’I’)(’o’|’O’)(’n’|’N’)

’_’(’b’|’B’)(’l’|’L’)(’o’|’O’)(’c’|’C’)(’k’|’K’);

54 FUZZIFY : (’f’|’F’)(’u’|’U’)(’z’|’Z’)(’z’|’Z’)(’i’|’I’)(’f’|’F’)(’y’|’Y’);

IF : (’i’|’I’)(’f’|’F’);

56 IS : (’i’|’I’)(’s’|’S’);

LM : (’l’|’L’)(’m’|’M’);

58 LN : (’l’|’L’)(’n’|’N’);

LOG : (’l’|’L’)(’o’|’O’)(’g’|’G’);

60 MAX : (’m’|’M’)(’a’|’A’)(’x’|’X’);

METHOD : (’m’|’M’)(’e’|’E’)(’t’|’T’)(’h’|’H’)(’o’|’O’)(’d’|’D’);

62 MIN : (’m’|’M’)(’i’|’I’)(’n’|’N’);

MM : (’m’|’M’)(’m’|’M’);

64 NC : (’n’|’N’)(’c’|’C’);

NOT : (’n’|’N’)(’o’|’O’)(’t’|’T’);

66 NSUM : (’n’|’N’)(’s’|’S’)(’u’|’U’)(’m’|’M’);

OR : (’o’|’O’)(’r’|’R’);

68 PROBOR : (’p’|’P’)(’r’|’R’)(’o’|’O’)(’b’|’B’)(’o’|’O’)(’r’|’R’);

39

KAPITEL 5. ANTLR

PROD : (’p’|’P’)(’r’|’R’)(’o’|’O’)(’d’|’D’);

70 RANGE : (’r’|’R’)(’a’|’A’)(’n’|’N’)(’g’|’G’)(’e’|’E’);

RM : (’r’|’R’)(’m’|’M’);

72 RULE : (’r’|’R’)(’u’|’U’)(’l’|’L’)(’e’|’E’);

RULEBLOCK : (’r’|’R’)(’u’|’U’)(’l’|’L’)(’e’|’E’)(’b’|’B’)(’l’|’L’)(’o’|’O’)(’c’|’C’)(’k’|’K’);

74 SIGM : (’s’|’S’)(’i’|’I’)(’g’|’G’)(’m’|’M’);

SIN : (’s’|’S’)(’i’|’I’)(’n’|’N’);

76 SINGLETONS : (’s’|’S’)(’i’|’I’)(’n’|’N’)(’g’|’G’)(’l’|’L’)(’e’|’E’)(’t’|’T’)(’o’|’O’)

(’n’|’N’)(’s’|’S’);

78 SUM : (’s’|’S’)(’u’|’U’)(’m’|’M’);

TAN : (’t’|’T’)(’a’|’A’)(’n’|’N’);

80 TERM : (’t’|’T’)(’e’|’E’)(’r’|’R’)(’m’|’M’);

THEN : (’t’|’T’)(’h’|’H’)(’e’|’E’)(’n’|’N’);

82 TRAPE : (’t’|’T’)(’r’|’R’)(’a’|’A’)(’p’|’P’)(’e’|’E’);

TRIAN : (’t’|’T’)(’r’|’R’)(’i’|’I’)(’a’|’A’)(’n’|’N’);

84 TYPE_REAL : (’r’|’R’)(’e’|’E’)(’a’|’A’)(’l’|’L’);

VAR_INPUT : (’v’|’V’)(’a’|’A’)(’r’|’R’)’_’(’i’|’I’)(’n’|’N’)(’p’|’P’)(’u’|’U’)(’t’|’T’);

86 VAR_OUTPUT : (’v’|’V’)(’a’|’A’)(’r’|’R’)’_’(’o’|’O’)(’u’|’U’)(’t’|’T’)(’p’|’P’)(’u’|’U’)(’t’|’T’);

WITH : (’w’|’W’)(’i’|’I’)(’t’|’T’)(’h’|’H’);

88// -----------------------------------------------------------------------------

90 // Lexer

// -----------------------------------------------------------------------------

92// Send runs of space and tab characters to the hidden channel.

94 WS: (’ ’ | ’\t’)+ { $channel = HIDDEN; };

96 // Treat runs of newline characters as a single NEWLINE token.

// On some platforms , newlines are represented by a \n character.

98 // On others they are represented by a \r and a \n character.

NEWLINE: (’\r’? ’\n’)+ { $channel=HIDDEN; };

100// Common symbols

102 ASSIGN_OPERATOR : ’:’ ’=’;

COLON : ’:’;

104 COMMA : ’,’;

DOT : ’.’;

106 DOTS : ’..’;

HAT : ’^’ ;

108 LEFT_CURLY : ’{’;

LEFT_PARENTHESIS: ’(’;

110 MINUS : ’-’ ;

PERCENT : ’%’ ;

112 PLUS : ’+’ ;

RIGHT_CURLY : ’}’;

114 RIGHT_PARENTHESIS: ’)’ ;

SEMICOLON : ’;’ ;

116 SLASH : ’/’ ;

STAR : ’*’ ;

118// A number is a set of digits

120 fragment NUMBER : (DIGIT )+;

122 // A DIGIT

fragment DIGIT : ’0’..’9’ ;

124// A letter

126 fragment LETTER: LOWER | UPPER;

fragment LOWER: ’a’..’z’;

128 fragment UPPER: ’A’..’Z’;

130 // Letter or digit

fragment ALPHANUM : LETTER | DIGIT;

132// Real number (float/double) without any sign

134 REAL : (PLUS|MINUS)? NUMBER ( ’.’ NUMBER )? (’e’ (PLUS|MINUS)? NUMBER )? ;

136 // FCL style comments

COMMENT options { greedy = false; }

138 : ’(*’ .* ’*)’ NEWLINE? { $channel=HIDDEN; };

140 // ’C’ style comments

COMMENT_C options { greedy = false; }

142 : ’/*’ .* ’*/’ NEWLINE? { $channel=HIDDEN; };

144 // ’C’ style single line comments

COMMENT_SL : ’//’ ~(’\r’ | ’\n’)* NEWLINE { $channel=HIDDEN; };

146// An identifier.

148 ID : LETTER (ALPHANUM | ’_’)*;

150 // -----------------------------------------------------------------------------

// Parser

152 // -----------------------------------------------------------------------------

40

KAPITEL 5. ANTLR

154 // FCL file may contain several funcion blocks

main : f=fcl -> ^(FCL $f);

156 fcl : (function_block )+;

158 // Function block

function_block : FUNCTION_BLOCK^ (ID)? (declaration )* END_FUNCTION_BLOCK !;

160 declaration : var_input | var_output | fuzzify_block | defuzzify_block | rule_block;

162 // Variables input and output

var_input : VAR_INPUT^ (var_def )* END_VAR !;

164 var_output : VAR_OUTPUT^ (var_def )+ END_VAR !;

var_def : ID^ COLON! data_type SEMICOLON! (range)? ;

166// Fuzzify

168 fuzzify_block : FUZZIFY^ ID (linguistic_term )* END_FUZZIFY !;

linguistic_term: TERM^ ID ASSIGN_OPERATOR! membership_function SEMICOLON !;

170 membership_function : function | singleton | singletons | piece_wise_linear | gauss | trian |

trape | sigm | gbell | cosine | dsigm ;

172 cosine: COSINE^ atom atom;

dsigm: DSIGM^ atom atom atom atom;

174 gauss: GAUSS^ atom atom;

gbell: GBELL^ atom atom atom;

176 piece_wise_linear: (points )+;

sigm: SIGM^ atom atom;

178 singleton : atom;

singletons: SINGLETONS^ (points )+ ;

180 trape: TRAPE^ atom atom atom atom;

trian: TRIAN^ atom atom atom;

182 points : LEFT_PARENTHESIS x=atom COMMA y=atom RIGHT_PARENTHESIS -> ^( POINT $x $y);

atom : ID | REAL;

184// Functions (for singletons)

186 function: FUNCTION^ fun_pm;

fun_pm: fun_md ((PLUS^ | MINUS^ ) fun_md )*;

188 fun_md: fun_mp ((STAR^ | SLASH^) fun_mp )*;

fun_mp : fun_atom ((HAT^ | PERCENT ^) fun_atom )*;

190 fun_atom : atom | (EXP^|LN^|LOG^|SIN^|COS^|TAN^|ABS^)? LEFT_PARENTHESIS! fun_pm RIGHT_PARENTHESIS !;

192 // Defuzzify

defuzzify_block : DEFUZZIFY^ ID (defuzzify_item )* END_DEFUZZIFY !;

194 defuzzify_item : defuzzification_method | default_value | linguistic_term | range;

range : RANGE^ ASSIGN_OPERATOR! LEFT_PARENTHESIS! REAL DOTS! REAL RIGHT_PARENTHESIS! SEMICOLON !;

196 defuzzification_method : METHOD^ COLON! (COG|COGS|COGF|COA|LM|RM|MM) SEMICOLON !;

default_value : DEFAULT^ ASSIGN_OPERATOR! (REAL | NC) SEMICOLON !;

198// Ruleblock

200 rule_block : RULEBLOCK^ ID (rule_item )* END_RULEBLOCK !;

rule_item : operator_definition | activation_method | accumulation_method | rule;

202 operator_definition : operator_definition_or | operator_definition_and;

operator_definition_or : OR^ COLON! (MAX|ASUM|BSUM) SEMICOLON !;

204 operator_definition_and : AND^ COLON! (MIN|PROD|BDIF) SEMICOLON !;

activation_method : ACT^ COLON! (PROD|MIN) SEMICOLON !;

206 accumulation_method : ACCU^ COLON! (MAX|BSUM|NSUM|PROBOR|SUM) SEMICOLON !;

rule : RULE^ rule_name COLON! if_clause then_clause (with)? SEMICOLON! ;

208 rule_name : ID | REAL;

if_clause : IF^ condition;

210 then_clause : THEN^ conclusion;

condition : subcondition ((AND^|OR^) subcondition )*;

212 subcondition : (NOT^)? (subcondition_bare | subcondition_paren );

subcondition_bare : ID^ (IS! (NOT)? ID)? ;

214 subcondition_paren : LEFT_PARENTHESIS! condition RIGHT_PARENTHESIS !;

conclusion : sub_conclusion (COMMA! sub_conclusion )?;

216 sub_conclusion : ID^ IS! ID;

with: WITH^ REAL;

218// Data type

220 data_type : TYPE_REAL;

B. FCLTreeWalker.g

1 tree grammar FCLTreeWalker;

3 options {

tokenVocab=Fcl;

5 ASTLabelType = CommonTree;

output=AST;

7 }

@header {


41

KAPITEL 5. ANTLR

11 import org.apache.log4j.Logger;

import java.util.Map;

13 import java.util.ArrayList;

15 import de.lab4inf.fcl.FCLTreeWalkerPartitionBuilder;

import de.lab4inf.fcl.FCLTreeWalkerRuleBuilder;

17 import de.lab4inf.fuzzy.FuzzyPartition;

import de.lab4inf.fuzzy.controller.FuzzyRule;

19 }

21 @members {

private FCLTreeWalkerPartitionBuilder partitionBuilder = new FCLTreeWalkerPartitionBuilder ();

23 private FCLTreeWalkerRuleBuilder ruleBuilder = new FCLTreeWalkerRuleBuilder ();

private String setType = null;

25 private String norm = null;

private String accu_method = null;

27 private String activation_method = null;

private static Logger logger = Logger.getLogger("de.lab4inf.fuzzy");

29 public Map <String , FuzzyPartition > getPartitions () {

return partitionBuilder.getPartitions ();

31 }

33 public ArrayList <FuzzyRule > getRules () {

return ruleBuilder.getRules ();

35 }

37 public String getNormName () {

return norm;

39 }

41 public String getAccuMethodName () {

return accu_method;

43 }

45 public String getActivationMethodName () {

return activation_method;

47 }

}

49main : ^(FCL fcl);

51 fcl : (function_block )+ {logger.info("Walker Start");};

53 // Function block

function_block : ^( FUNCTION_BLOCK (ID)? (declaration )*);

55 declaration : var_input | var_output | fuzzify_block | defuzzify_block | rule_block;

57 // Variables input and output

var_input : ^( VAR_INPUT (var_def )*);

59 var_output : ^( VAR_OUTPUT (var_def ));

var_def : ^(ID data_type ) ;

61// Fuzzify

63 fuzzify_block : ^( FUZZIFY ID (linguistic_term )*) {logger.info("Walker: fuzzify_block: " + $ID.text);

partitionBuilder.newPartition($ID.text);

65 };

linguistic_term: ^(TERM ID membership_function) {logger.info("Walker: Linguistic Term: " + $ID.text);

67 partitionBuilder.newSet($ID.text , setType );

};

69 membership_function : function | singleton | singletons | piece_wise_linear | gauss | trian | trape

| sigm | gbell | cosine | dsigm ;

71 cosine: ^( COSINE atom atom){

setType = "cosine";

73 logger.info("POLYGON");

};

75 dsigm: ^(DSIGM atom atom atom atom){

setType = "dsigm";


};

79 gauss: ^(GAUSS center=atom delta=atom){

double pCenter = Double.parseDouble ((( Tree)( center.getTree ())). toStringTree ());

81 double pDelta = Double.parseDouble ((( Tree)( delta.getTree ())). toStringTree ());

partitionBuilder.addPoint(pCenter , 0);

83 partitionBuilder.addPoint(pDelta , 0);

setType = "gauss";


};

87 gbell: ^(GBELL atom atom atom){

setType = "gbell";

89 logger.info("GBELL");

};

91 piece_wise_linear: (points )+ {

setType = "polygon";


};

42

KAPITEL 5. ANTLR

95 sigm: ^(SIGM atom atom){

setType = "sigm";

97 logger.info("SIGM");

};

99 singleton : x0=atom {

double pX0 = Double.parseDouble ((( Tree)(x0.getTree ())). toStringTree ());

101 partitionBuilder.addPoint(pX0 , 0);

setType = "singelton";

103 logger.info("SINGLETON");

};

105 singletons: ^( SINGLETONS (points )+) {

setType = "singeltons";

107 logger.info("SINGLETONS");

};

109 trape: ^(TRAPE l=atom ml=atom mr=atom r=atom) {

setType = "trapez";

111 logger.info("TRAPE");

double lp = Double.parseDouble ((( Tree)(l.getTree ())). toStringTree ());

113 double mlp = Double.parseDouble ((( Tree)(ml.getTree ())). toStringTree ());

double mrp = Double.parseDouble ((( Tree)(mr.getTree ())). toStringTree ());

115 double rp = Double.parseDouble ((( Tree)(r.getTree ())). toStringTree ());

partitionBuilder.addPoint(lp , 0);

117 partitionBuilder.addPoint(mlp , 0);

partitionBuilder.addPoint(mrp , 0);

119 partitionBuilder.addPoint(rp , 0);

};

121 trian: ^(TRIAN left=atom mean=atom right=atom) {

double leftp = Double.parseDouble ((( Tree)(left.getTree ())). toStringTree ());

123 double meanp = Double.parseDouble ((( Tree)(mean.getTree ())). toStringTree ());

double rightp = Double.parseDouble ((( Tree)( right.getTree ())). toStringTree ());

125 partitionBuilder.addPoint(leftp , 0);

partitionBuilder.addPoint(meanp , 0);

127 partitionBuilder.addPoint(rightp , 0);

setType = "triangle";

129 logger.info("TRIAN");

};

131 points : ^(POINT x=atom y=atom) {

double xp = Double.parseDouble ((( Tree)(x.getTree ())). toStringTree ());

133 double yp = Double.parseDouble ((( Tree)(y.getTree ())). toStringTree ());

partitionBuilder.addPoint(xp , yp);

135 logger.info("POINT: " + ((Tree)(x.getTree ())). toStringTree () + " " + ((Tree)(y.getTree ())). toStringTree ());};

atom : ID | REAL;

137// Functions (for singletons)

139 function: FUNCTION^ fun_pm;

fun_pm: fun_md ((PLUS^ | MINUS^ ) fun_md )*;

141 fun_md: fun_mp ((STAR^ | SLASH^) fun_mp )*;

fun_mp : fun_atom ((HAT^ | PERCENT ^) fun_atom )*;

143 fun_atom : atom | (EXP^|LN^|LOG^|SIN^|COS^|TAN^|ABS^)? LEFT_PARENTHESIS! fun_pm RIGHT_PARENTHESIS !;

145 // Defuzzify

defuzzify_block : ^( DEFUZZIFY ID (defuzzify_item )*) {

147 logger.info("Walker: defuzzify_block: " + $ID.text);

partitionBuilder.newPartition($ID.text );};

149 defuzzify_item : defuzzification_method | default_value | linguistic_term | range;

range : ^( RANGE REAL);

151 defuzzification_method :

^( METHOD (COG)) {logger.info("Defuzzifaction Method = COG");}

153 |^( METHOD (COGS))

|^( METHOD (COGF))

155 |^( METHOD (COA))

|^( METHOD (LM))

157 |^( METHOD (RM))

|^( METHOD (MM));

159 // defuzzification_method : ^( METHOD COG);

default_value : ^( DEFAULT (REAL | NC));

161// Ruleblock

163 rule_block : ^( RULEBLOCK ID (rule_item )*) {logger.info("Walker: rule_block: " + $ID.text );};

rule_item : operator_definition | activation_method | accumulation_method | rule;

165 operator_definition : operator_definition_or | operator_definition_and;

operator_definition_or : ^(OR (MAX{norm = "FuzzyMinMax";}| ASUM {norm = "FuzzyAlgebraic";}|

167 BSUM {norm = "FuzzyBoundedNorm";}));

operator_definition_and : ^(AND (MIN{norm = "FuzzyMinMax";}| PROD {norm = "FuzzyAlgebraic";}|

169 BDIF {norm = "FuzzyBoundedNorm";}));

activation_method : ^(ACT (PROD{activation_method = "FuzzyAlgebraic";}|

171 MIN {activation_method = "FuzzyMinMax";}));

accumulation_method : ^(ACCU (MAX{accu_method="FuzzyMinMax";}| BSUM{accu_method="FuzzyBoundedNorm";}));

173 rule : ^(RULE rule_name if_clause then_clause (with )?);

rule_name : ID {

175 ruleBuilder.setPartitions(partitionBuilder.getPartitions ());

ruleBuilder.setRuleName($ID.text);

177 logger.info("Walker: rule_name (ID): " + $ID.text );}

| REAL {

43

KAPITEL 5. ANTLR

179 ruleBuilder.setPartitions(partitionBuilder.getPartitions ());

ruleBuilder.setRuleName($REAL.text);

181 logger.info("Walker: rule_name (REAL): " + $REAL.text );};

if_clause : ^(IF condition );

183 then_clause : ^(THEN conclusion) {logger.info("Walker: then_clause");};

condition : ^(OR condition condition ) {ruleBuilder.addOrRelation ();

185 logger.info("Walker: condition(OR)");}

| ^(AND condition condition) {ruleBuilder.addAndRelation ();

187 logger.info("Walker: condition(AND)");}

| subcondition{logger.info("Walker: condition");};

189 // condition : subcondition ((AND^|OR^) subcondition )*;

subcondition : (NOT^)? (subcondition_bare );

191 subcondition_bare : ^(x=ID ( (NOT)? y=ID)?) {

ruleBuilder.addVariable($x.text , $y.text);

193 logger.info("Walker: subcondition_bare " +$x.text+ " " + $y.text );};

// subcondition_paren : condition;

195 conclusion : sub_conclusion (sub_conclusion )* {ruleBuilder.clearConditionStack ();};

sub_conclusion : ^(x=ID y=ID) {ruleBuilder.addConclusion($x.text , $y.text); ruleBuilder.newRule ();} ;

197 with: ^(WITH REAL);

199 // Data type

data_type : TYPE_REAL;

201atom1 : atom;

203 atom2 : atom;

44

6. Jefis Ruleengine

Listing 6.1: FCL-Datei Applet BeispielFUNCTION_BLOCK applet

2VAR_INPUT

4 service : REAL;

food : REAL;

6 END_VAR

8 VAR_OUTPUT

tip : REAL;

10 waiter : REAL;

END_VAR

12FUZZIFY service

14 TERM poor := (0, 1) (4, 0);

TERM good := (1, 0) (4,1) (6,1) (9 ,0);

16 TERM excellent := (6, 0) (9, 1);

END_FUZZIFY

18FUZZIFY food

20 TERM rancid := (0, 1) (1, 1) (3,0);

TERM delicious := (7,0) (9,1);

22 END_FUZZIFY

24 DEFUZZIFY tip

TERM cheap := (0,0) (5,1) (10 ,0);

26 TERM average := (10 ,0) (15,1) (20 ,0);

TERM generous := (20 ,0) (25 ,1) (30 ,0);

28 END_DEFUZZIFY

30 DEFUZZIFY waiter

TERM sad := (-1.1,0) (-1,1) (0,1) (3 ,0);

32 TERM normal := (2,0) (4,1) (5,1) (7 ,0);

TERM happy := (6,0) (9,1) (9.5 ,1) (9.6 ,0);

34 END_DEFUZZIFY

36 RULEBLOCK No1

RULE 1 : IF service IS good AND food IS delicious THEN tip IS generous;

38 RULE 2 : IF tip IS generous THEN waiter IS happy;

END_RULEBLOCK


45

Abbildungsverzeichnis

1.1. Beispiel Fuzzy Partition fur einen Wertebereich von 0 bis 80 . . . . . . . . 41.2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3. Beispiel Fuzzy-Regler in einem Schaltbild . . . . . . . . . . . . . . . . . . 61.4. Flugbahn und Geschwindigkeitskorrektur uber Fuzzy . . . . . . . . . . . . 81.5. Schaltplan der Flugbahn und Geschwindigkeitskorrektur . . . . . . . . . . 81.6. Bierglas auf Inversen Pendel; Fuzzysets des Beispiels . . . . . . . . . . . . 91.7. Regeln des Inversen Pendels . . . . . . . . . . . . . . . . . . . . . . . . . . 91.8. Komponenten eines Regelbasierten Systems [Bec] . . . . . . . . . . . . . . 101.9. UML Diagramm der wichtigsten Jefis Klassen [NW09] . . . . . . . . . . . 13

2.1. Auflistung der unterschiedlichen Rete-OO Knoten . . . . . . . . . . . . . . 162.2. Baum fur die im Listing gezeigte Regel . . . . . . . . . . . . . . . . . . . . 172.3. Klassendiagramm des Jefis-Drools-Adapters . . . . . . . . . . . . . . . . . 20

3.1. Applet zur Visualisierung der Implikation . . . . . . . . . . . . . . . . . . 24

4.1. Der erzeugte Beispielbaum. . . . . . . . . . . . . . . . . . . . . . . . . . . 35

46

Literaturverzeichnis

[Bec] Becker, P.: Wissensbasierte Systeme II. Vorlesung an der FH Bonn RheinSieg.

[Bei06] Beierle, C. und Kern-Isberner, G.: Methoden wissensbasierter Systeme:Grundlagen-Algorithmen-Anwendungen. Vieweg + Teubner Verlag, 2006.

[Dre] Drexl, M.N. und Koch, M.: Modellierung von Geschaftsregeln. Modellbasierte Softwareentwicklung, Seite 103.

[dro10] JBoss Drools Documentation ”Drools Expert“. Website, Juni 2010.Verfugbar online unter http://downloads.jboss.com/drools/docs/5.0.1.26597.FINAL/drools-expert/html_single/index.html; besucht am 18.Juni 2010.

[DS08] Davide Sottara, Paola Mello und Mark Proctor: Rule Representa-tion, Interchange and Reasoning on the Web, Kapitel Adding uncertainty toa Rete-OO inference engine, Seiten 104–118. Springer, 2008.

[DWM08] Dr. Wolfgang Martin, Thomas Cotic und Lars Wunderlich: DasEnde des Software-Release-Zyklus? - Business Rules Management. Jaxenter,2008.

[iec10] FCL Entwurf der IEC. Website, Juni 2010. Verfugbar online unter http://www.fuzzytech.com/binaries/ieccd1.pdf; besucht am 18. Juni 2010.

[mve10] MVEL Codehaus Projektseite. Website, Juni 2010. Verfugbar online unterhttp://mvel.codehaus.org/; besucht am 18. Juni 2010.

[Nel05] Nellessen, P.: Vortriebssynchrone Prognose der Setzungen bei Flussigkeitsschildvortrieben auf Basis der Auswertung der Betriebsdaten mitHilfe eines Neuro-Fuzzy-Systems. Cuvillier Verlag, 2005.

[NW09] Nikolaus Wulff, Davide Sottara: Rule Interchange and Applications,Kapitel Fuzzy Reasoning with a Rete-OO Rule Engine. Springer Berlin /Heidelberg, 2009.

[Pul00] Pullmann, T.: Implementierung eines wissensbasierten Softwaresystemszum Entwurf und zur Bemessung von Stahlbeton-Tragwerken. TU Darmstadt,Vertieferarbeit, 2000.

47

http://downloads.jboss.com/drools/docs/5.0.1.26597.FINAL/drools-expert/html_single/index.html

http://downloads.jboss.com/drools/docs/5.0.1.26597.FINAL/drools-expert/html_single/index.html

http://www.fuzzytech.com/binaries/ieccd1.pdf

http://www.fuzzytech.com/binaries/ieccd1.pdf

http://mvel.codehaus.org/

Literaturverzeichnis

[Sot10a] Sottora, D.: Blog Drools Chance. Website, Juni 2010. Verfugbar onlineunter http://blog.athico.com/search/label/Drools%20Chance; besuchtam 18. Juni 2010.

[Sot10b] Sottora, D.: Drools Chance Repisitory. Website, Juni 2010. Verfugbaronline unter https://svn.jboss.org/repos/labs/labs/jbossrules/branches/DroolsChance; besucht am 18. Juni 2010.

48

http://blog.athico.com/search/label/Drools%20Chance

https://svn.jboss.org/repos/labs/labs/jbossrules/branches/DroolsChance

https://svn.jboss.org/repos/labs/labs/jbossrules/branches/DroolsChance

Date post:	15-Jul-2020
Category:	Documents
Upload:	others
View:	3 times
Download:	0 times

Fuzzylogik und Regelbasierte Systemesierte Systeme, die f ur das Verst andnis der Ausarbeitung...

Documents