MLF - jvr.at

Transcrição

MLF - jvr.at

Bakkalaureatsarbeit '03 - MLF
Richard Springle / Jürgen Repolusk
Bakkalaureatsarbeit
Datamining
mit
Machine Learning Framework
(MLF)
Richard Springle
Jürgen Repolusk
unter der Leitung von Dr. Rudolf Seising
Institut für Medizinische Computerwissenschaften
Abteilung für Medizinische Expertenund Wissensbasierte Systeme
-1-
Mathematica ® ist ein eingetragenes Warenzeichen von © Wolfram Research Inc.
Windows © ist ein eingetragenes Warenzeichen der © Microsoft Coropration
Linux ist ein eingetragenes Warenzeichen von Linus Torvalds
Oracle ® ist ein eingetragenes Warenzeichen der © Oracle Corporation
MLF - machine learning framework © ist ein eingetragenes Warenzeichen
der Uni Software Plus GmbH
Dieses Dokument unterliegt der GNU GFDL (General Free Documentation Licence)
GNU Free Documentation License
Version 1.2, November 2002
Copyright (C) 2000 - 2003 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Version 1.5.8
-2-
Inhaltsverzeichnis
• 1 Einleitung.....................................................................................................................5
• 2 Über Mathematica....................................................................................................10
• 3 Fuzzy-Logik...............................................................................................................12
• 3.1 Definitionen.........................................................................................................12
3.1.1 Scharfe Mengen...............................................................................................12
3.1.2 Unscharfe Mengen...........................................................................................13
3.1.3 Linguistische Variablen...................................................................................14
3.1.4 Fuzzy-Operatoren............................................................................................15
3.1.5 Fuzzy-Relationen.............................................................................................16
3.1.6 Fuzzifizierung..................................................................................................17
3.1.7 Defuzzifizierung..............................................................................................20
• 4 Machine Learning Framework (MLF)...................................................................23
• 5 Mathematica und MLF unter Linux.......................................................................24
• 6 Supervised Learning mit MLF................................................................................25
• 6.1 Einführung...........................................................................................................25
6.1.1 FS-ID3 (Fuzzy-Set Instruction of Decission Trees).......................................27
6.1.2 FS-FOIL..........................................................................................................29
• 6.2 Vorgehensweise beim „Supervised Learning“....................................................31
6.2.1 Anlegen der Daten bzw. eines Datenobjektes.................................................33
6.2.2 Attribut-Matrix Plott des Datenobjektes.........................................................39
6.2.3 Grafische Skizzierung der Attribut-Matrix.....................................................44
6.2.4 Definition von Fuzzy-Sets...............................................................................47
6.2.5 Grafische Skizzierung der Attribut-Matrix mit Einbeziehung von Fuzzy-Sets .
50
6.2.6 Erzeugung eines „Decision-Trees“ .................................................................53
6.2.7 Auswertung der Ergebnisse.............................................................................57
6.2.8 Erzeugen und testen einer Regelbasis ............................................................60
Optimieren von Regelbasen (FS-RENO).................................................................69
• 6.3 Fazit.....................................................................................................................70
• 7 Unsupervised Learning mit MLF............................................................................72
• 7.1 Einführung zur Cluster-Analyse..........................................................................72
7.1.1 Ähnlichkeits- und Distanzmaße......................................................................73
7.1.2 Clusteranalytische Verfahren..........................................................................74
• 7.2 SOM (Kohonen maps).........................................................................................76
7.2.1 Grundsätzlich Arbeitsweise einer SOM..........................................................76
7.2.2 Beispiel für SOM mit Mathematica & MLF...................................................77
• 7.3 Fuzzy K-Means (clustering)................................................................................82
• 7.4 WARD (crisp clustering).....................................................................................82
7.4.1 Beispiel für WARD (crisp clustering).............................................................83
-3-
• 7.5 Clusterberechnung mit verschiedenen Methoden...............................................89
• 7.6 Fazit.....................................................................................................................91
• 8 Kurzreferenz..............................................................................................................93
• 9 Literaturhinweise....................................................................................................101
-4-
1 Einleitung
Dies ist ein Bericht über ein Projekt im Bakkalaureatsstudium mit folgender
Aufgabenstellung, bei der drei primäre Ziele erreicht werden sollten:
-
Ermittlung der Nutzbarkeit des Tool MLF (Machine Learning Framework) der
Firma SCCH (Software Competence Center Hagenberg) in medizinischen
Bereichen.
Betrachtung der Arbeitsweise von MLF und dessen Möglichkeiten Fuzzy-Logik
zu verwenden.
Testen der Benutzerfreundlichkeit für den Benutzer.
Daraus ergeben sich folgende sekundäre Ziele:
-
Anwendung von MLF auf ein konkretes Beispiel.
Verfügbarkeit von MLF auf verschiedenen Systemplattformen (Windows/Linux).
Betrachtung der Integrierbarkeit von MLF in den medizinischen Arbeitsalltag.
Kurze Beschreibung des Lösungsweges und der Ergebnisse:
MLF ist eine Implementierung der Datamining-Methode, das heißt der Bearbeitung einer
Menge von Daten und der Extrahierung von Erkenntnissen durch verschiedene
Algorithmen, die Zusammenhänge zwischen den einzelnen Daten darstellen.
MLF wurde als Template, sprich Paket, für Mathematica1 entwickelt. MLF selbst wurde
in C++ geschrieben, die Operationen und Funktionen derer es sich bedient wurden in der
Syntax von Mathematica verfasst und in eigenen Bibliotheken gesammelt. Das
Datamining kann in folgende vier Arbeitsschritte aufgeteilt werden;
•
Im ersten Teilschritt werden alle Daten, welche nicht für ein mögliches Ergebnis
relevant sind aus der Datenmenge entfernt.
•
Im zweiten Arbeitsschritt werden die übrig gebliebenen Daten entsprechend den
Voraussetzungen für den dritten Teilschritt gelichtet, das heißt die Daten werden so
behandelt, daß sie in einer Form vorliegen, die der gewünschte Algorithmus
verarbeiten kann.
•
Im dritten Teilschritt werden die vorbehandelten Daten durch einen Algorithmus
verarbeitet. Diese Algorithmen haben als Eingabe die Datenmenge, die als Ergebnis
1
Mathematica ist eine Software der Firma Wolfram Research zur Verarbeitung/Bearbeitung/Lösung
von komplexen mathematischen Problemen.
-5-
vom letzten Teilschritt vorliegen, und liefern als Ausgabe entweder Regelbasen in
Form von aussagelogischen Prädikaten oder Entscheidungsbäume bestehend aus
Blättern, Kanten und Knoten.
•
Im letzten Schritt werden die Ergebnisse der Algorithmen vom Benutzer begutachtet
und bewertet.
MLF wurde derart entwickelt, daß es bereits sehr früh in den Prozess des „Datamining“
eingreift. Unter dem Tool MLF stehen dem Anwender zwei Vorgehensweisen zur
Verfügung.
•
„Supervised Learning“ ist ab der Bearbeitung der Daten, also dem zweiten Teilschritt
des „Datamining“, anwendbar.
•
„Unsupervised Learning“ ab der Extrahierung der Daten, also dem ersten Teilschritt
des „Datamining“.
„Supervised Learning“ eignet sich zur Bearbeitung von Daten die bereits vom Benutzer
gesichtet und bearbeitet wurden. Daher setzt diese Vorgehensweise eine genaue
Zielsetzung der Ergebnisse voraus. Ebenfalls von Vorteil sind mögliche Vermutungen
über die Zusammenhänge zwischen den Daten.
„Unsupervised Learning“ verlangt vom Anwender keine Vorbehandlung der Daten. Da
jedoch der Rechenaufwand für „Unsupervised Learning“ exponentiell ansteigt, bedeutet
das, daß große Datenmengen mit dieser Methode zwar verarbeitbar sind, dies aber aus
kapazitätsgründen nicht empfehlenswert ist.
„Unsupervised Learning“ wurde als vorangestellter Arbeitsschritt zum „Supervised
Learning“ konzipiert. Das bedeutet daß die möglichen Ergebnisse beider
Vorgehensweisen diesselben sind, wobei unter „Supervised Learning“ ein Teilschritt
eingespart werden kann.
Als mögliches Ergebnis können entweder Regelbasen oder Entscheidungsbäume erstellt
werden, optional können auch bereits existierende Regelbasen optimiert werden.
„Supervised Learning“ bedient sich der folgenden Algorithmen:
•
•
•
•
FS-ID3 (Erstellung von Entscheidungsbäumen),
FS-Foil (Erstellung von Regelbasen),
FS-Miner (Erlernung von Fuzzy-Regeln) und des
FS-Reno (Optimierung von Fuzzy-Controllern).
„Unsupervised Learning“ verwendet die folgenden Algorithmen:
•
SOM („Self organized maps“, Kohonen Netzwerk),
-6-
•
•
Fuzzy K-Means und den
WARD (Clustering durch Minimierung der Fehlerquadratsumme).
Daraus ergibt sich, daß das Tool MLF durch seine Eigenschaften beschränkt für die
Anwendung auf medizinische Daten geeignet ist. Sobald die Daten vorverarbeitet wurden
und es nicht mehr notwendig ist, das „Unsupervised Learning“ durchzuführen, ist die
Verarbeitungsdauer übersehbar. Ist die Datenmenge jedoch sehr groß und nicht
vorbehandelt so wird es dadurch notwendig, „Unsupervised Learning“ durchzuführen.
Dadurch steigt der Rechenaufwand dermaßen an, dass die Auswertung der Daten zu viel
Zeit benötigen würde.
Die Benutzung von Fuzzy-Logik bedeutet, dass die verwendete Art der Fuzzifizierung
und der Defuzzifierung und sogar eigene definierte Fuzzy-Sets angegeben werden
können. Da eigene Fuzzy-Sets definiert werden können, ist es möglich die Entstehung
von Regelbasen oder Entscheidungsbäumen direkt vom Benutzer beeinflussen zu lassen
und nicht nur durch die Veränderung der Datenmenge, welche dem verwendeten
Algorithmus gegeben werden.
Das heißt, daß MLF Fuzzy-Logik benutzt, wenn es Vorteile bietet.
Die Benutzerfreundlichkeit von MLF wird sehr stark dadurch beeinflußt, daß es eine
Erweiterung zu Mathematica ist. Dabei mußten sich die Entwickler von MLF an die
Syntax der Funktionen und Arbeitsweisen von Mathematica halten. Deswegen gestaltet
sich unter MLF die Arbeit gleich wie unter Mathematica. Folglich sind die einzelnen
Verarbeitungsschritte, die zu einem gewünschten Ergebnis führen, von der richtigen
Anwendung einer Menge von Operationen und Funktionen abhängig. Somit besitzt die
Arbeit unter MLF einen ähnlichen Charakter wie die der Benutzung einer
Programmiersprache. Dies mag zwar im ersten Augenblick abschreckend wirken, ist aber
eigentlich ein Vorteil, da somit der Kreativität des Benutzer fast keine Grenzen gesetzt
sind. In der Regel sieht die Benutzung von MLF folgendermaßen aus: Nach dem Laden
des Paketes MLF für Mathematica stehen dem Benutzer alle Operationen und Funktionen
die er benötigen könnte zur Verfügung. Selbst eine Hilfefunktion und Tutorials sind unter
Mathematica für MLF abrufbereit. Somit ist die Arbeit im ersten Moment ungewohnt,
aber durchaus erlernbar und auch benutzerfreundlich.
Um die Funktionalität von MLF nachzuweisen, sollte die Verarbeitung eines
medizinischen Beispiels mit der dazugehörigen Dokumentation der Arbeitsschritte
erfolgen. Leider jedoch wurden keine brauchbaren medizinischen Daten zur Verfügung
gestellt, denn die verfügbaren medizinischen Daten waren entweder in einer komplexen
Datenstruktur verpackt oder ohne die Dokumentation dazu vorhanden. Somit stand die
Verarbeitung der Daten in keinem vernünftigen Verhältnis zum Nutzen, oder aber der
Zusammenhang zwischen den Attributen der Daten war zu klar, um Regeln direkt aus
den Daten heraus zu lesen. Deswegen war es am Sinnvollsten, aussagekräftige
Beispieldaten, welche direkt von MLF mitgeliefert werden, zu verwenden.
-7-
In der Dokumentation der Verarbeitung der Beispieldaten in MLF sind folgende
Verarbeitungsschritte festgehalten:
•
•
•
•
Aufbereitung der Datenmenge,
Verwendung von Funktionen bzw. Operationen,
Output von MLF,
Referenz der verwendeten Funktions- und Operationsaufrufe.
„Supervised Learning“ und „Unsupervised Learning“ beziehen sich auf verschiedene
Beispieldaten. Der Grund dafür liegt darin, dass sich beide Verfahren dadurch
unterscheiden, dass sie einerseits vollständige Datensätze („Supervised Learning“),
andererseits unvollständige Datensätze („Unsupervised Learning“) verarbeiten.
Die Verfügbarkeit von MLF auf verschiedenen Plattformen ist nicht gegeben. Die zu dem
Tool MLF mitgelieferte Installationsroutine bedient einzig und alleine Windowsbenutzer. (Somit unterstützt MLF ursprünglich nur Windows Plattformen.) Da jedoch
MLF eine Erweiterung zu Mathematica ist und auf dessen Kernel, Routinen Operationen
etc. zurückgreift, genügt es, einen passenden Emulator für die gewünschte Plattform zu
finden oder zu entwickeln, welche in diesem Fall eine Emulation für Windows bietet. Da
für fast alle Plattformen eine solche Emulation existiert, kann MLF unter sehr vielen
Betriebssystemen genutzt werden. Die Arbeitsgeschwindigkeit von MLF leidet zwar
unter einer Emulation für Windows, da der Rechenaufwand bei vielen Arbeitsschritten
von MLF enorm ist, trotzdem wird so die Verfügbarkeit und Einsetzbarkeit von MLF
erhöht.
Wie für die Benutzerfreundlichkeit ist auch die Integrierbarkeit von MLF in den
normalen Arbeitsalltag dadurch bestimmt, dass die in MLF verwendeten Funktionen und
Operationen denen in einer funktionalen Programmiersprache verwendeten Bibliothek
gleichen. Durch die Bearbeitung der Beispieldaten ergab sich dies sehr deutlich.
MLF benötigt mit seiner abstrakten Bedienungsumgebung eine gewisse
Einarbeitungszeit, da die Syntax der Operationen und Funktionen, wie bereits erwähnt,
sehr gewöhnungsbedürftig ist. Durch den Dialog zwischen dem Benutzer und MLF, der
sehr technisch gehalten sein muss, fällt der Umgang mit MLF Informatikern und anderen
Technikern am Anfang bestimmt leichter, als Wissenschaftlern anderer Disziplinen.
Trotzdem ist der Umgang selbsterklärend und fügt sich daher in den Arbeitsalltag nach
einer kurzen Einarbeitungszeit, poblemlos ein.
-8-
Zusammenfassend ist zu sagen, daß bei der Anwendung von MLF auf konkrete
Datensätze wie den Celipert- und Toxoplasmose-Daten folgende Probleme auftraten:
•
•
Die Celipert-Daten waren einerseits nicht dokumentiert, andererseits zu unvollständig.
Die Toxoplasmosedaten waren zu einfach strukturiert um daraus verborgene
Zusammenhänge zu erfassen.
Daraus ergab sich, dass das Tool MLF für die Verwendung im medizinischen Bereich nur
unter bestimmten Bedingungen anwendbar ist:
•
•
•
Das Datenmaterial soll möglichst vollständig sein.
Die Daten sollen gut dokumentiert sein.
Qualitative Daten sind wichtiger als quantitative Daten.
Zusätzlich
verlangt
MLF
vom
Benutzer,
bedingt
durch
den
programmiersprachenähnlichen Aufbau, ein hohes Maß an Abstraktionsfähigkeit.
Hinzu kommt, dass der Anwender eine relative genaue Vorstellung über die
Zusammenhänge zwischen den Attributen der Daten haben sollte. MLF sucht zwar
danach, aber der Rechenaufwand und somit der Zeitaufwand sinken erheblich, wenn
gezielt gesucht werden kann.
-9-
2 Über Mathematica
Mathematica ist ein umfangreiches Computeralgebrasystem, das über den Aufruf von
Funktionen und Operationen bedient werden kann. Mathematica besteht aus zwei
Komponenten:
•
•
dem Frontend für die Kommunikation mit dem Anwender und die Darstellung der
Ein- und Ausgaben in mathematischer Notation bzw. für die grafische Ein- und
Ausgabe
dem Kernel, der die eigentlichen Rechnungen durchführt.
Für umfangreiche Berechnungen kann der Kernel auch ohne die grafische Oberfläche des
Frontends benutzt werden. Mathematica ist nach der Installation sofort einsatzbereit. Alle
Funktionen von Mathematica besitzen die gleiche Syntax und sind ausführlich im
Hilfesystem beschrieben. Dieses System ist zudem nicht statisch, sondern so dynamisch,
daß es möglich ist, direkt aus der Hilfe heraus dem Kernel Rechenaufgaben zu
übergeben.
Mathematica ist kein proprietäres, sondern ein nach allen Seiten offenes und
standardisiertes System, das sich nahezu beliebig anpassen lässt. Es besteht aus mehreren
plattformunabhängigen Komponenten, die für den Nutzer meistens unsichtbar im
Hintergrund die Arbeit verrichten:
•
•
•
•
•
•
Der mathematische Kernel (sozusagen das Wissensbuch der Mathematik).
Das plattformunabhängige "Notebookinterface" (die Benutzeroberfläche: identisch für
Windows, Macintosh, Linux, Unix).
MathLink, das Kommunikationsprotokoll zwischen Kernel und der
Benutzeroberfläche.
MathML zur Darstellung von Formeln im WWW.
J/Link, die Schnittstelle zu Java.
MathLM, die Lizenzmanagersoftware zur Kontrolle und Steuerung der Zugriffe.
Aufgrund der offenen Standards ist es möglich, den mathematischen Kernel an nahezu
jede andere Software oder Benutzeroberfläche anzudocken. So sind zum Beispiel
Zusatzmodule zur direkten Anbindung an Microsoft Excel, Microsoft Access, Origin,
LabView, Oracle verfügbar (Machine Learning Framework ist auch eines dieser
Zusatzmodule). Selbst dem Internet gegenüber zeigt sich der Kernel via J/Link offen und
kann als webMathematica die unternehmensweite Mathematiklösung oder einfach die
Black-Box im Hintergrund von Internet-basierten Analysen und Grafen sein.
Und reicht die Leistung eines Computers einmal nicht aus, wird durch den Einsatz des
Zusatzmodules "Parallel Computing Toolkit" die dem Kernel übergebene Rechenaufgabe
auf mehrere unterschiedliche Systeme aufgeteilt (Stichwort: Verteilte Systeme).
-10-
Die Mathematik gibt Antwort auf entscheidende Probleme diverser Bereiche des
Ingenieuralltags, von der Physik über die Anwendung in der Medizin bis zur
Finanzwirtschaft. Antworten, die mit gesundem Menschenverstand allein oft nicht zu
finden sind. Wirkliche Probleme weisen nicht nur vier oder fünf Parameter auf, sondern
im Extremfall hunderte. Hierbei sind elektronische Helfer, die uns das Expertenwissen
schnell und zuverlässig liefern, notwendig. Mathematica ist einer dieser elektronischen
Helfer.
Als Alternative zu herkömmlichen, rein numerischen Methoden wie Finiten Elementen
gewinnt die Computer-Algebragestützte Simulation in zahlreichen Gebieten an
Bedeutung. Mathematica beherrscht beide Methoden und erlaubt den direkten Vergleich
der Ansätze in einem System.
Aus diesem Grund hat sich Mathematica in den letzten Jahren aus dem universitären und
wissenschaftlichen Bereich kommend, mehr und mehr in der industriellen Ingenieurstätigkeit etabliert.
Spezialisten rund um den Globus komprimieren ihr Expertenwissen zu kommerziellen
Anwendungspaketen - entworfen und programmiert in Mathematica - und bieten dieses
Know-How als Zusatzmodule an. Hier sind einige Beispiele davon:
•
•
•
•
•
•
•
•
•
Control Systems Professional
Experimental Data Analyst
Fuzzy-Logik
Technical Trader
Scientific Astronomer, Optica
Industrial Thermics
Operations Research
MathTensor
usw.
In unserem Fall der Anwendung im medizinischen Bereich, ist vor allem der Punkt
Fuzzy-Logik von großer Bedeutung. Das “Machine Learning Framework (MLF)” fällt in
diese Kategorie und ist deswegen auch von besonderem Interesse für die medizinische
Informatik.
-11-
3 Fuzzy-Logik
Die Entwicklung der Fuzzy-Logik geht auf Lotfi A. Zadeh zurück, der sich vor ca. 25
Jahren mit diesen Ansätzen beschäftigte. Zadeh hat für diesen neuen Ansatz der Logik
die so genannten Fuzzy-Sets eingeführt, um nicht exakte und unvollständige Datensätze
(von daher der Begriff „fuzzy“), wie sie in der Wirklichkeit nur allzu oft auftreten,
mathematisch beschreiben und weiterverarbeiten zu können. Unter anderem hat sich
diese Theorie sowohl in der Mustererkennung, Entscheidungstheorie und
Regelungstechnik als auch in der Medizin als sehr nützlich erwiesen. In Japan trat man
dieser neuen Theorie relativ aufgeschlossen gegenüber, in Europa hingegen traf man
nahezu über 20 Jahre hinweg auf Zurückhaltung und Distanzierung. Somit blieb man im
westlichen Kulturkreis der klassischen zweiwertigen Logik für lange Zeit fest und
unveränderlich verhaftet. Erst in den letzten Jahren begann ein Umdenken hin zur FuzzyLogik.
3.1 Definitionen
3.1.1 Scharfe Mengen
Eine Menge wird dadurch definiert, dass alle ihre Elemente wohlunterschieden werden.
Definiert man noch zusätzlich eine Abbildung, die alle Elemente der Menge bezüglich
einer Eigenschaft auf die Werte Null oder Eins abbildet, erhält man zwei scharfe
Mengen. Somit ist eine scharfe Menge dadurch ausgezeichnet, dass alle ihre Elemente
eine gewisse Eigenschaft besitzen.
Die charakteristische Funktion für die scharfe Menge ist folgendermaßen definiert:
µA  x : X  {0,1}
µA  x =1 für x∈ A
µA  x =0 für x ∉ A
-12-
Hier als Beispiel die Darstellung der Temperatur durch eine charakteristische Funktion µ
für eine scharfe Menge:
3.1.2 Unscharfe Mengen
Eine unscharfe Menge kann man nur dadurch erhalten, daß man für die
Zugehörigkeitsfunktion nicht nur die diskreten Werte Null und Eins zulässt, sondern auch
beliebige reelle Werte dazwischen. Dadurch wird es möglich, einen Übergang zwischen
„zugehörig“ und „nicht zugehörig“ festzulegen. Mathematisch gesehen sieht dies
folgendermaßen aus:
Gegeben sei der Merkmalsraum X und die Teilmenge A von X:
A⊆ X
Weiters sei folgende Zugehörigkeitsfunktion definiert:
µA  x : X [0,1]
Somit wird durch diese Funktion jedem Element x aus A ein Zugehörigkeitsgrad µA(x)
aus dem Intervall [0,1] zugewiesen. Die so entstandene Menge A wird als unscharfe
beziehungsweise als Fuzzy-Menge bezeichnet.
-13-
Hier als Beispiel die Darstellung der Temperatur durch eine Zugehörigkeitsfunktion µ für
eine unscharfe Menge:
3.1.3 Linguistische Variablen
Es sollte nun gezeigt werden, wie Variablen durch eine Zugehörigkeitsfunktion µ(x)
dargestellt werden können. Dazu bedient man sich der Fuzzy-Sets. Diese werden durch
Zugehörigkeitsfunktionen beschrieben. Mathematisch kann ein Fuzzy-Set
folgendermaßen beschrieben werden:
A={ x , µA  x ∣x ∈ X }
µA(x), die Zugehörigkeitsfunktion die x in A in die Menge X auf den Zugehörigkeitsraum
abbildet. Der Bereich der Zugehörigkeitsfunktion ist eine Untermenge der reellen Zahlen
mit endlicher Obergrenze und der Untergrenze Null.
Linguistische Variablen sind nichts anderes als die Zusammenfassung von ganzen Sätzen
von Fuzzy-Mengen, die ein und diesselbe Kenngröße charakterisieren, die dann zu einer
linguistischen Variable zusammengefasst werden können. Konkret ist eine linguistische
Variable ein Mengensystem folgender Art:
VL = {A, X, G, B}
wobei:
• G eine Menge von syntaxtischen Regeln ist, die die linguistische Diskretisierung von
-14-
•
•
•
VL bestimmt.
Die Menge A aus der Menge G resultierende Terme beinhaltet.
X ist die physikalisch relevante Grundmenge.
Die Menge B inkludiert die semantischen Regeln, welche jedem Term seine
physikalische Bedeutung über die Grundmenge X zuordnet.
3.1.4 Fuzzy-Operatoren
Mit Hilfe der Fuzzy-Operatoren lassen sich Fuzzy-Sets der gleichen Grundmenge
miteinander verknüpfen. Die wichtigsten Verknüpfungsarten sind OR, AND und NOT.
•
AND Operator
Für die AND-Verknüpfung zweier Fuzzy-Sets wird der Minimum Operator verwendet,
definiert durch den Durchschnitt zweier unscharfer Mengen:
A∧B≡µA∩B  x =min µA  x  , µB  x , x∈ X
-15-
•
OR Operator
Für die Oder-Verknüpfung zweier Fuzzy-Sets wird der Maximum Operator verwendet.
Definiert durch die Vereinigung zweier unscharfer Mengen:
A∨B≡µA∪B  x =max µA  x  , µB  x  , x∈ X
•
NOT Operator
Für das Komplement einer unscharfen Menge A wird die Negation verwendet:
¬A≡µ¬A  x =1−µA  x  , x ∈ X
3.1.5 Fuzzy-Relationen
Die bisherigen Verknüpfungen zielten lediglich auf Fuzzy-Mengen der selben
Grundmenge ab. Nun soll dazu übergegangen werden Fuzzy-Sets unterschiedlicher
Grundmengen zueinander in Relation zu setzen. Dies bewerkstelligt man unter
Zuhilfenahme des kartesischen Produkts, wobei Regeln der Form
IF p THEN c
modelliert werden. Eine Regel, die auch als Implikation bezeichnet wird, besteht aus
einer Prämisse p und einer Konklusion c. Geht man davon aus, dass die Prämisse p durch
-16-
das Fuzzy-Set X1 und die Konklusion c durch das Fuzzy-Set X2 beschrieben ist, so
definiert das kartesische Produkt eine unscharfe Ausgangsmenge X.
pc
p∈ X 1
c∈ X 2
3.1.6 Fuzzifizierung
Mittels der Fuzzyfizierung werden die Zugehörigkeitswerte aller linguistischen
Elementaraussagen bestimmt, die die Ein- und Ausgangsgrößen des Fuzzy-Reglers
betreffen. Die Anzahl der linguistischen Terme sowie auch der Grad der Überlappungen
der einzelnen unscharfen Mengen ist vom jeweiligen Anwendungsfall abhängig. Meist
unterliegt dies der Entscheidung des Entwicklers beziehungsweise des Anwenders.
Regelbasis
Die Regelbasis enthält die sogenannten Produktionsregeln. Darin befindet sich das
Expertenwissen zur Regelung des Prozesses. Diese Regelbasis für eine Anzahl von k
Produktionsregeln (R1, R2,... Rk) kann allgemein folgendermaßen beschrieben werden:
Rk: IF pk THEN ck
Rk
pk
ck
Produktionsregel
Prämissen als Funktion der Eingangsgröße
Konklusionen als Aussagen
Beispiel für die Steuerung eines Ventils für die Wasserzufuhr einer Badewanne:
IF (Temperatur = heiß AND Gradient = hoch) OR Temperatur=sehr heiß THEN
Ventilstellung = ganz zu
Die in der Regelbasis enthaltenen Regeln sollten das Ergebnis der eingehenden
Systemanalyse eines Prozesses sein und nach Möglichkeit widerspruchsfrei und
vollständig sein. Mit einer solchen Regelbasis ist es also möglich, Entscheidungen
anhand von Eingangsgrößen zu treffen. Oft ist es sehr hilfreich, sich eine solche
Regelbasis als Tabelle zu visualisieren.
-17-
Hier ist ein Beispiel für eine Visualisierung in Form einer Tabelle:
AND
Gradient
Temperatur
negativ
null
positiv
sehr kalt
ganz offen
ganz offen
offen
kalt
ganz offen
offen
offen
warm
mittel
mittel
zu
heiß
zu
zu
ganz zu
sehr heiß
zu
ganz zu
ganz zu
Inferenz
Unter Inferenz versteht man die Auswertung der Regeln einer Regelbasis und die
anschließende Zusammenfassung der daraus abzuleitenden Handlungsanweisungen als
Grundlage für eine zu implementierende Entscheidungsstrategie. Man sollte hierbei
beachten, daß man quasi völlig freie Hand bei der Auswahl der Strategie hat.
Die Auswertung der Regeln laufen nach folgendem Schema ab:
•
Ermittlung der aktiven Regeln: Es werden zu Beginn jene Regeln aus der Regelbasis
in Betracht genommen, deren Prämissen einen Erfülltheitsgrad größer als Null
aufweisen.
•
Ermittlung der einzelnen Ausgangs- und Fuzzy-Mengen. Dafür wird zuerst für jede
aktive Regel der Wahrheitswert der Prämisse bestimmt. Dieser Wert gibt an, zu
welchen Grad die Regel erfüllt ist. In der Abhängigkeit der gewählten
Entscheidungsstrategie liefert die Implikation nun unterschiedliche
Zugehörigkeitsmaße.
Entscheidungsstrategien:
MAX-MIN-Inferenz:
Dieses von Zadeh und Mamdani entworfene Schema ist das wohl verbreitestete
überhaupt. Dabei wird der OR-Verknüpfung der max-Operator; der AND- und der
Implikation-Verknüpfung der min-Operator zugewiesen.
-18-
OR
AND
Implikation
max
min
min
Beispielbild zur MAX-MIN-Inferenz:
MAX-PROD-Inferenz
Bei dieser Inferenz werden für AND und OR die gleichen Operatoren wie bei der MAXMIN-Inferenz verwendet. Jedoch wird für die Implikation statt eines min-Operators der
Produkt-Operator (.) verwendet.
OR
AND
Implikation
max
min
(.)
-19-
Beispielbild zu MAX-PROD-Inferenz:
3.1.7 Defuzzifizierung
Unter Defuzzifizierung versteht man die Ermittlung eines scharfen Wertes aus einer
unscharfen Menge. Übliche Methoden zur Defuzzifizierung sind:
Maximum Height
Diese Methode liefert als Ausgangsgröße uS den Wert, für den die
Zugehörigkeitsfunktionen der Ausgangsmenge U ihr Maximum erreichen.
µU u S =max µU u
Der Vorteil darin liegt in der einfachen Berechnung von uS aus µU. Zu Problemen kann es
jedoch kommen, wenn in µU(u) mehrere Maxima auftreten.
-20-
Hier dazu Beispielbild:
Mean of Maximum
Hier wird der Maximum-Mittelwert berechnet. Die Mean of Maximum Methode liefert als
Ausgangsgröße uS das arithmetische Mittel aller Werte, für die die
Zugehörigkeitsfunktion µU(u) maximal ist. Hierbei können Probleme entstehen, wenn im
µU Verlauf mehrere plateauartige Verläufe vorhanden sind, auf denen überall der
Maximalwert gegeben ist.
Beispiel:
-21-
Center of Gravity
Die sogenannte Schwerpunktsmethode liefert als Ausgangsgröße uS, die u Komponente
des Schwerpunkts der Fläche unter dem µ(u) Grafen. Hierbei wird die
Zugehörigkeitsfunktion als Fläche aufgefasst. Die scharfe Ausgangsgröße uS erhält man
durch die Berechnung der Komponente u des Flächenschwerpunkts unter dem Grafen µ
(u).
Die Formel dafür lautet:
uS =
∫ u⋅µu u⋅du
u
∫ µu u⋅du
u
Der Vorteil in dieser Methode liegt darin, daß der gesamte Verlauf der
Zugehörigkeitsfunktion in die Berechnung des scharfen Wertes miteinbezogen wird.
Aber auch bei dieser Methode kann ein Problem auftreten, denn der Zugehörigkeitswert
kann unter Umständen sehr klein sein.
Beispiel:
-22-
4 Machine Learning Framework (MLF)
Machine Learning Framework (MLF) ist ein AddOn für Mathematica, welches es
ermöglicht, eine Menge von Algorithmen für maschinelles Lernen auf Daten
anzuwenden.
Fuzzy-basierende Lernmethoden gehören dazu. MLF wurde vom Software Competence
Center Hagenberg GmbH (www.scch.at) entwickelt und wird von der Firma Uni
Software Plus GmbH (www.unisoftwareplus.com) vertrieben. Ein Teil der
Implementation von MLF wurde in C++, der andere in Mathematica, durchgeführt. MLF
sollte laut Herstellerangaben unter allen Microsoft Windows-Systemen lauffähig sein.
Lernalgorithmen von MLF:
Supervised Learning:
•
FS-ID3 (fuzzy decision trees)
•
FS-FOIL (fuzzy rule learning)
•
FS-MINER (fuzzy rule learning)
•
RENO (optimizing for fuzzy controllers)
Unsupervised Lerning:
•
SOM (Kohonen maps)
•
Fuzzy K-Means (clustering)
•
WARD (crisp clustering)
Zusätzliche Features:
•
Advanced scatter plots
•
Parallel coordinates visualization
•
Fuzzy-Logik (using different types of fuzzy-sets and t-normes)
•
Fuzzy-Inference (Mandani, Sugeno, Tagaki-Sugeno-Kang)
Die Software kann von http://www.unisoftwareplus.com/products/MLF/ heruntergeladen
werden. Um MLF zu installieren, ist es notwendig, daß Mathematica bereits auf dem
Rechner vorinstalliert wurde. Beim ersten Start des MLF AddOns ist die Eingabe eines
„Licence Keys“ erforderlich, der direkt von der Firma SCCH angefordert werden muss.
-23-
5 Mathematica und MLF unter Linux
Wenn man das MLF-Tool unter Linux benutzen will, so ist es notwendig zuerst
Mathematica mit der Windows Emulation Wine (http://www.winehq.com/ ) unter Linux
zu installieren. Wichtig ist, dass nicht die Linux Installation von Mathematica ausgeführt
wird, da MLF sonst nicht ausführbar wird. Das ist zwar ein wenig umständlich, aber nicht
anders möglich, da momentan noch kein direkter Support von MLF unter Linux
vorhanden ist.
Nach beziehungsweise während des Installationsprozesses kann es vorkommen (wenn
man noch keine Windows Fonts für Wine installiert hat), daß an dem User-Interface von
Mathematica kryptische, sinnlose Zeichenketten ausgegeben werden. Um die ausgebenen
Zeichen richtig darstellen zu können, müssen die Schriftsätze einer vorhandenen
Windows-Installation (in C:\Windows\Fonts\ ) in das Fonts-Verzeichnis der WineWindows-Partition kopiert werden.
(zum Beispiel in: ~/.wine/fake_windows/Windows/Fonts/ ) Wenn keine existierende
Windows Installation vorhanden ist, ist es möglich, eine Sammlung von Fonts von
folgender Internetseite herunterzuladen: http://corefonts.sourceforge.net/ .
Nachdem alle Schriftsätze installiert wurden und alle Zeichen korrekt dargestellt sind,
folgt die übliche Registrierung von Mathematica beim ersten Start des Programms.
Erst nachdem Mathematica installiert wurde, kann MLF unter Wine integriert werden.
(downloadbar von: http://www.unisoftwareplus.com/products/MLF/download.html )
Der Installationsvorgang sollte ohne Komplikationen ablaufen und nach seinem
Abschluß sollte MLF unter Mathematica aufrufbar sein. Wie unter MS Windows wird
MLF mit dem Befehl Needs ['MLF'] geladen. Die Verarbeitungsgeschwindigkeit von
MLF leidet trotz der Emulation nur geringfügig und sollte im Arbeitsbetrieb nicht
auffallen.
-24-
6 Supervised Learning mit MLF
Anfang der 70er Jahre des 20. Jahrhunderts entstand der Wunsch, die menschliche
Eigenschaft des Lernens und die Fähigkeit des Interpretierens maschinell nachzubilden.
Unter der wissenschaftlichen Disziplin des „Data Minings“ werden alle Theorien,
Algorithmen und Erkenntnisse zusammengefasst, welche sich mit dieser Aufgabe
beschäftigen.
Die Ergebnisse auf diesem Gebiet sind heute schon so weit fortgeschritten, dass „Data
Mining“ seit mehr als 10 Jahren industriell eingesetzt wird.
Die Anwendungen sind vielfältig, sie reichen von der Suche nach Verhaltensmustern von
Kunden eines Einkaufszentrum bis zur Auffindung von Regeln bzw. Zusammenhängen
zwischen Datensätzen von einmal aufgezeichneten Daten.
Für die Medizin ist gerade der zweite Punkt des Findens von Regeln besonders
interessant, denn dort gibt es auch noch heute Krankheiten, für welche es keine korrekten
Diagnoseregeln gibt, jedoch ausreichend unaufgearbeitetes Dokumentationsmaterial.
Außerdem mehrt sich der Wunsch, den Arzt in seiner Arbeit mit „Expertensystemen“ zu
unterstützen, um ihn somit von Routinearbeit zu befreien.
Jedes Expertensystem benötigt eine Regelbasis, mit welcher aus einer Menge von
Inputwerten ein Outputwert generiert wird. Der Output stellt eine Entscheidung dar, die
als eine Diagnose interpretiert werden kann.
Unter einer Regelbasis ist zu verstehen, dass es sich dabei um eine Vorschrift (einer Art
von Algorithmus) handelt, welche einen genau definierten Input an Attributen mit genau
definiertem Wertebereich beinhaltet und basierend darauf auf ein bestimmtes
„Zielattribut“ zu schließen vermag.
Außerdem gibt es in der Medizin genügend Dokumentationen, welche ausreichend
Informationen enthalten, um zu versuchen, aus ihnen neues Wissen durch „Data Mining“
zu gewinnen.
Abschließend folgt daraus, dass „Data Mining“ eine geeignete Vorgehensweise ist, um
vorhandene Datenbanken in der Medizin aufzuarbeiten und vor allem sinnvoll zu nutzen.
6.1 Einführung
„Data Mining“ gliedert sich grob in drei Abschnitte. Im ersten Abschnitt werden die
Daten aufbereitet.
Als erster Schritt wird unnötiger „Datenmüll“ erkannt und entfernt, das heisst es werden
alle Attribute und deren Ausprägungen in den vorhandenen Daten entfernt, die in keiner
zu vermuteten Beziehung zum Zielattribut stehen. Damit wird versucht unnötiger
Rechenaufwand zu vermeiden.
Danach müssen die Daten in verarbeitungsfreundliche Form gebracht werden, was
beudetet das Konvertierungen auf den bereits aussortierten Daten durchgeführt werden
-25-
müssen, um diese für die Verarbeitung mit den verschiedensten Algorithmen
vorzubereiten.
Im zweiten Abschnitt wird versucht, aus den aufbereiteten Daten „neues Wissen“ zu
extrahieren. Für diesen Zweck existieren je nach Bedarf und Aufgabenstellung „DataMining-Algorithmen“ die auf die Daten angewandt werden können.
Im dritten und letzten Schritt wird das somit generierte Wissen auf dessen
„Sinnhaftigkeit“ hin betrachtet, bewertet und interpretiert.
Das Template „MLF“ für Mathematica, bietet einerseits die Methode des „Unsupervised
Learnings“ und andererseits die Methode des „Supervised Learnings“, um „Data Mining“
auf beziehungsweise bei Daten anzuwenden.
„Unsupervised Learning“ optimiert bzw.verbessert die Qualität gegebener Daten oder es
ergänzt fehlende Merkmalsausprägungen zu einem Datensatz, sofern dies überhaupt
möglich ist.
„Unsupervised Learning“ greift ab dem ersten Schritt des „Data Minings“ ein. Das
Ergebnis dieser Methode sind aufbereitete Daten (bzw. selbstorganisierende
Datenstrukturen), welche als Input für die Vorgangsweise des „Supervised Learnings“
benutzt werden können.
„Supervised Learning“ verlangt hingegen bereits aufbereitete Daten als Eingabe für die in
dieser Methode verwendeten Algorithmen. Der Einsatz dieses Verfahrens ist auch erst ab
dem dritten Teilschritt von „Data Mining“ (Anwendung von Algorithmen) gedacht. Als
Ergebnis liefert „Supervised Learning“ im Gegenzug zu „Unsupervised Learning“
wahlweise Entscheidungsbäume oder Regelbasen. (Wahlweise kann auch eine
Optimierung von Fuzzy-Controllern bzw. Regelwerken vorgenommen werden).
Als Ergebnis haben beide Methoden dasselbe Ziel der Generierung von neuem Wissen
aus bestehenden Daten.
Insgesamt ist zu vermerken, dass „Unsupervised Learning“ für die Bearbeitung von
„rohen Daten“ und „Supervised Learning“ für die Bearbeitung von bereits
aufgearbeiteten Daten geeignet ist.
Dieses Kapitel beschäftigt sich mit allen relevanten Teilen und Aspekten des
„Supervised Learnings“. Im Anschluß daran wird „Unsupervised Learning“ vorgestellt
und in all seinen Facetten diskutiert.
„Supervised Learning“ setzt nicht, wie durch die vorigen Angaben zu vermuten wäre, bei
dem Anwender ein „extrem“ genaues Bewusstsein über die möglichen Zusammenhänge
zwischen den Attributen seiner Daten voraus. Jedoch ist dies für einen schnelleren
Fortschritt der Arbeit sehr empfehlenswert. Eine Vermutung genügt, um für das
„Supervised Learning“ alle Angaben machen zu können, die für die Durchführung dieser
Methodik benötigt werden.
„Supervised Learning“ bietet dem Benutzer eine Vielfalt von Eingriffsmöglichkeiten, die,
falls dieser es wünscht, genutzt werden können. Oft können durch ein paar manuelle
Veränderungen (z.B Änderung von Fuzzy-Sets) die Ergebnisse verbessert werden
beziehungsweise es kann dem Rechner viel Arbeit abgenommen werden. Dadurch ist
-26-
auch gewährleistet, das der Kreativität des Benutzers keine Grenzen gesetzt sind.
Für das „Supervised Learning“ wurden insgesamt vier Algorithmen implementiert:
•
•
•
•
FS-ID3,
FS-FOIL,
FS-MINER (Entwicklung der Firma SCCH)
RENO (Entwicklung der Firma SCCH)
Die Algorithmen, FS-Miner und RENO wurden von der Firma SCCH entwickelt, somit
ist die genaue Vorgehensweise nur der Firma selbst bekannt ist. FS-MINER
ermöglicht das Erlernen von Fuzzy-Regeln und RENO optimiert Fuzzy-Controler.
6.1.1 FS-ID3 (Fuzzy-Set Instruction of Decission Trees)
Der Algorithmus FS-ID3 wurde von J. Quinlan 1979 in seiner Grundform formuliert.
Wie der Name bereits vermuten läßt, erstellt der Algorithmus einen Entscheidungsbaum
für die Klassifizierung einer Datenmenge bezüglich eines Attributes .
Im Entscheidungsbaum sind die Knoten die Attribute, (deren Werte für die Bestimmung
des Ziellattributes hergenommen werden), die Kanten die dazugehörigen
Merkmalsausprägungen und die Blätter die Entscheidungsklassen (die
Merkmalsausprägungen zu dem Zielattribut).
Daraus folgt, dass mit der Anzahl der Attribute und der dazugehörigen
Merkmalsausprägungen auch die Regeln unweigerlich komplexer werden.
Im Entscheidungsbaum ist jeder mögliche Pfad eine Regel. Diese Regeln können
aussagelogisch (daher auch fuzzyfizierbar) dargestellt werden, wobei jeder Pfad von der
Wurzel zu einem Blatt einer Konjunktion entspricht (alle Kanten die von einem Knoten
zu einem gleichen anderen Knoten führen, werden durch Fuzzy-Sets zusammengefaßt).
Alle Pfade, die zur selben Klasse führen, werden disjunktiv zusammengefasst und die
Klassen am Blattknoten werden zu einer Konklusion. (Die Konjunktionen entlang eines
Pfades werden dadurch zu Vorbedingungen.)
-27-
Aussagenlogische Verknüpfungen erstellt aus einem Entscheidungsbaum:
Die genaue Formulierung und Vorgehensweise des Algorithmus lautet:
Gegeben: Menge klassifizierter Beispiele E
Algorithmus: createTree (E)
-28-
IF E = {}
THEN RETURN Blattknoten, der mit einer “geeigneten” Klasse markiert ist
IF alle Beispiele in E gehören zur selben Klasse C
THEN RETURN Blattknoten der mit C markiert ist
SELEKTIERE eine EFFIZIENTES Attribut A mit dem Wertebereich {w1,...,wn}
PARTITIONIERE E in E1,...,En abhängig von den Wertausprägungen von A
BERECHNE rekursive: T1:= createTree(E1) ,..., Tn:= createTree(En)
RETURN Baum mit Wurzel A und den mit w1,...,wn markierten
Kanten zu den Unterbäumen T1,...,Tn
Die Eigenschaften des Algorithmus sind folgende:
•
•
•
Es gibt nur endliche Wertebereiche (das heißt symbolische „diskrete“ Attribute)
Bei leeren Beispielmengen wird die Klasse mit der größten Häufigkeit im
Vorgängerknoten zugeordnet.
Die Attributauswahl geschieht aufgrund von „Informationsgewinn“
Da FS-ID3 eine heuristische Methode ist um einen Entscheidungsbaum zu konstruieren,
ist seine Effizienz in der Praxis nicht immer optimal, da jedoch das Problem der
Konstruktion an und für sich ein NP-vollständiges ist, stellt der Algorithmus eine gute
Annäherung an eine optimale Lösung und Laufzeit dar.
6.1.2 FS-FOIL
Der Algorithmus FS –FOIL wurde 1990 ebenfalls von J. Quinlain formuliert. Genauso
wie der FS-ID3 Algorithmus hat er Informationsgewinn zum Ziel.
Anders als der FS-ID3 sucht er nach einer Menge von Hornklauseln (Regeln), die
Prädikate (die Konzepte) beschreiben.
Die Hornlogik basiert auf der Prädikatenlogik, wobei eine „Hornklausel“ (oder einfach
nur Klausel) aus Literalen mit höchstens einem negierten Literal besteht, Klauseln mit
keinem negierten Literal werden Fakten genannt.
Der Algorithmus geht dabei so vor, daß er die Definition des Prädikates erlernt (Hillclimbing-Suche), das heißt er „erlernt“ startend von einem leeren Klauselrumpf durch
schrittweises Hinzufügen von Literalen die passenden Regeln. Somit erlernt der
Algorithmus sowohl aus positiven (Grundatomformel mit Prädikat P) wie auch aus
negativen Beispielen (negierte Grundatomformel mit Prädikat P), wobei das Ziel lautet,
Klauseln zu finden, welche alle negativen „Beispiele“ (Eingangsattributwertepaare)
ausschließen und möglichst viele positive Beispiele einschließen. Damit wird erreicht,
dass die vom Algorithmus „erlernte“ Klauselmenge nur Fakten enthält und diese somit
korrekte Aussagen über die Eingabewerte treffen (bzw. korrekte Zuordnungen der
-29-
Eingangswerte zu den Merkmalsausprägungen des Zielattributes tätigen).
Beispiel:
Der Algorithmus ist folgendermaßen definiert:
Gegeben:
– zu lernendes Prädikat P(X1,...,Xn)
– Pos: Menge der positiven Beispiele (als Tupel notiert)
– Neg: Menge der negativen Beispiele (als Tupel notiert)
– BK: Hintergrundtheorie (endliche Menge von Fakten)
Algorithmus:
K := {}; (* zu lernende Klauselmenge *)
WHILE Pos ≠ {} DO
Pre := Lerne_Klauselrumpf
K := K ?{P(X1,...,Xn) :- Pre}
Pos := Pos \ { Menge der positiven Beispiele die Pre erfüllen }
Algorithmus: Lerne_Klauselrumpf
Pre := ()
Old := {X1,...,Xn} (* Menge der Variablen *)
WHILE Neg ≠ {} DO
-30-
FOR EACH Prädikat Q aus BK ?{P}
DO
Lit := Menge alle Literale mit Prädikat Q in denen nur Variablen
vorkommen wobei mindestens eine Variable aus Old ist.
FOR EACH Lit DO
Berechne den Informationsgewinn für L
Wähle L mit größtem Informationsgewinn aus
Pre := Pre L
Old := Old Menge der Variablen aus L
Pos := Menge aller Erweiterungen von Beispielen aus Pos die L erfüllen
Neg := Menge aller Erweiterungen von Beispielen aus Neg die L erfüllen
RETURN Pre
Die Eigenschaften des FS-FOIL Algorithmus sind:
•
•
Fs-Foil bietet eine mächtige Beschreibungsmöglichkeit für Konzepte. Es ist eine
Erstellung einer sehr genauen Wissensbasis möglich.
kann Hintergrundwissen (Paare von Attributen und Werten) optimal verarbeiten.
Die Nachteile des FS-Foil Algorithmus liegen in seiner Laufzeit, denn die Größe der zu
betrachtenden Literale steigt exponentiell mit der Menge der Prädikate und trotz der „hillclimbing-Vorgehensweise“ des Algorithmus besteht immer noch eine hohe Komplexität,
jedoch sind diese Nachteile bei allen Algorithmen zur Lösung von NP-vollständigen
Probleme in der Regel zu finden.
6.2 Vorgehensweise beim „Supervised Learning“
Um Algorithmen beim „Supervised Learning“ optimal einsetzen zu können, ist
diesbezüglich eine komplizierte Syntax zur Benutzung notwendig. Deswegen ist im
Gesamten gesehen die Syntax von MLF sehr umfangreich und ähnelt der einer
funktionalen Programmiersprache. Zur verwendeten Syntax ist noch zu erwähnen, dass
sie sich an der von Mathematica aufbaut und sich somit nahtlos in den Arbeitsfluss von
Mathematica einfügt.
Grundsätzlich lässt sich die Vorgehensweise im „Supervised Learning“ wie folgt
skizzieren:
1.) Anlegung der Daten bzw. eines Datenobjektes.
2.) Optionale grafische Darstellung des Datenobjektes durch einer Attribut-MatrixPlot in verschiedenen Darstellungsweisen (2 oder mehrdimensional).
-31-
3.) Optionale grafische Skizzierung ausgewählter Dimensionen der Attribut-Matrix
in verschiedenen Darstellungsweisen.
4.) Optionale Definition von Fuzzy-Sets.
5.) Optionale Darstellung der Attribut-Matrix mit Einbeziehung der Fuzzy-Sets in
verschiedenen Darstellungsweisen.
6.) Erzeugung eines „Decision Trees“ (FS-ID3)
7.) Vergleich der originalen Daten und der Ergebnisse des Entscheidungsbaums
8.) Erzeugung und Testung einer Regelbasis (FS-FOIL oder FS-MINER).
9.) Optimieren von Regelbasen (FS-RENO)
Die Angabe der optionalen Schritte ist für das Optimieren und dem Finden von richtigen
und vor allem sinngebenden Regelbasen (sowie Entscheidungsbäumen) unumgänglich,
aber für den rein technischen Weg nicht notwendig.
Diese Schritte sollten also nicht einfach ignoriert, sondern wenn nötig ausgeführt werden.
Im folgenden werden die einzelnen Schritte genauer erläutert und anhand eines sich
aufbauenden Beispiels dargestellt. Die Daten des Beispiels beinhalten eine Menge an
Datensätze, die eine Beschreibung der Pflanzenfamilie „Iris“ und ihrer Unterarten
beinhaltet. Als Attribute enthalten die Daten Breite und Länge der Blüten und Blätter
sowie den Namen der Unterart. Im Kapitel „Unsupervised Learning“ wird ein weiteres
Beispiel bearbeitet.
Die Daten aus den Beispielen sowohl von „Supervised“ als auch „Unsupervised
Learning“ stammen von mitgelieferten Datensätzen aus dem Tutorial für MLF.
Warum keine medizinischen Daten verwendet wurden ist aus der Einleitung und dem
Fazit zu entnehmen.
Bei den Beispielen (sowohl für das „Supervised“ als auch für das „Unsupervised
Learning“) werden verschiedene Operationen und Funktionen verwendet, die einerseits
von MLF und andererseits von Mathematica implementiert bereitgestellt werden.
Für die richtige Verwendung der Operationen und Funktionen ist es aber auch notwendig
die Syntax der verwendeten Funktionen bzw. Routinen soweit als notwendig zu erklären
und darzustellen.
Die Darstellung der Syntax findet in den folgenden Beispielen statt, im Anhang befindet
sich eine Zusammenfassung der verwendeten Funktionen und Operationen und deren
Syntax unter dem Abschnitt „Kurzreferenz“.
Für weitere Fragen bzgl. der Operationen steht auch die „Offline-Hilfe“ von Mathematica
unter der Rubrik „add-ons“ im Unterkapitel „Machine-Learning-Framework“ zur
Verfügung. Es sei noch erwähnt, dass das Hauptaugenmerk bei den Beispielen auf der
Vorgehensweise liegt und nicht auf dem richtigen Gebrauch der Operationen und
Funktionen. Deswegen wird die Syntax nur soweit als ausreichend erklärt und aufgeführt,
da sie den Sinn nicht weiter vertiefen kann und somit nicht zum weiteren Verständnis
beitragen und somit ablenken würde.
-32-
6.2.1 Anlegen der Daten bzw. eines Datenobjektes
Da Mathematica in seiner Funktionalität sehr umfangreich ist und somit schon viele
Bereiche der Mathematik und Anforderungen der Benutzer selbst abdeckt, ist auch die
Verwaltung und Organisation der Daten selbst ein Kompromiss.
Das heißt die Verwaltung der Daten und der Datenobjekte ist nur die kleinstmögliche
Schnittmenge der Anforderungen der implementierten Algorithmen und Funktionen.
Folglich ist die Verwaltung von Speicher und Ressourcen in Mathematica nicht für große
Datenmengen ausgelegt und wurde deshalb in MLF durch eine eigene neue
Speicherverwaltung der Daten und Datenobjekte ersetzt.
In MLF existieren 3 Typen, die „Basic Datatypes“, die „Operations“ und die
„Algorithmen“.
Unter dem Typus „Basic Datatypes“ befinden sich die „numerischen Wertebereiche
(Natürliche Zahlen, Reelle Zahlen etc.) sowie „logische Wertebereiche“ (wahr, falsch,
auch Fuzzy-Sets) und der Typus „Data Set“, welcher eine Mischung der logischen und
der numerischen Typen ist. Für jeden in MLF integrierten Datentyp existieren
Konstruktoren, mit welchen man Objekte des gewünschten Typus als Variable anlegen
und auch wieder zerstören kann. Es ist ebenso möglich, einem Ausdruck (jeder Ausdruck
entspricht einem Typen) einen Namen zuzuweisen, um ihn somit zu speichern.
In MLF werden auch Operationen (auch Funktionen genannt) als Objekte betrachtet,
wobei die Operationen immer Objekte der „Basic Datatypes“ manipulieren und
bearbeiten. Deswegen besitzen alle Operationen eine genau festgelegte Syntax und
erledigen auch nur bestimmte Aufgaben.
Auch Algorithmen werden als Objekte aufgefasst. Die in MLF integrierten Algorithmen
setzen sich aus den in MLF und Mathematica definierten Operationen und „Basic
Datatypes“ zusammen und repräsentieren den wichtigen Kern von MLF.
Die Algorithmen sind deswegen der Kern von MLF, da sie die Hauptaufgaben der
Berechnung übernehmen und somit die Aufgaben des Benutzers abarbeiten.
Um Berechnungen unter MLF mit den implementierten Algorithmen durchführen zu
können, müssen die entsprechenden Datenobjekte für die Algorithmen angelegt
beziehungsweise erstellt werden (Um welchen Typus es sich beim Datenobjekt handelt,
ist aus der Syntax des jeweiligen Algorithmus erkennbar).
Hierfür kann das Datenobjekt entweder selbst angelegt oder importiert werden, wobei für
den Benutzer der Import der Daten als Tabelle oder dergleichen am sinnhaftesten ist, da
die meisten Daten in Form von Tabellen vorliegen oder in relationalen Datenbanken
gespeichert sind und somit schnell für MLF verfügbar gemacht werden können. Wenn
-33-
die Daten nicht importiert werden, müssen sie manuell eingegeben werden, was bei mehr
als 15 Datensätzen nicht mehr zu empfehlen ist.
Um die Vorgehensweise besser zu erklären, wird wie bereits angekündigt ein Beispiel
eingeführt. Für tiefergreifende Erklärungen zur Syntax beziehungsweise zum Aufbau der
Operationen wird nochmals auf den Abschnitt „Kurzreferenz“ im Anhang verwiesen, wo
aufbauend und chronologisch der Abfolge der Beispiele folgend die genaue Notation der
Verwendungsweise der wichtigsten Funktionen und Algorithmen mit allen optionalen
Angaben dargestellt wird.
Zu Beginn muss ein Datenobjekt angelegt werden, welches entsprechend den eigenen
Vorstellungen und der Natur der Daten („das heißt wie die Daten vorliegen“) einen
bestimmten Typus besitzt.
Dafür muss eine Variable erstellt werden, die das Datenobjekt namentlich repräsentiert.
Auf diesen Variablennamen arbeiten auch alle in MLF implementierten Algorithmen.
Sobald einer Funktion oder Operation (somit auch einem Algorithmus) ein
Variablenname angegeben wird, wird ihm das passende Datenobjekt dazu übergeben.
Im Falle eines Datenobjektes mit Inhalt einer Tabelle (bzw. Im Falle von Datensätzen
allgemein), besteht das Datenobjekt wieder aus einer Vielzahl von Datenobjekten, welche
den Typus eines der „Basic Datatypes“ besitzt.
Unter dem Begriff Typus ist zu verstehen, dass es eine Implementierung gibt, die einem
mathematischen Modell (bzw. Vorstellung) in der reellen Welt entspricht (z.B.: die
reellen Zahlen.) Um mit diesen Modellen arbeiten zu können sind die dazu passenden
Operationen ebenfalls in Mathematica definiert.
Diese Menge von Operationen werden in Mathematica als Objekte angesehen, wie schon
eingangs erwähnt. Dadurch bekommt der Begriff des Objektes, betrachtet aus der Welt
der objektorientierten Programmierung, eine andere Bedeutung.
Der Begriff des Objektes ist nicht nur als „Datenstruktur“ interpretierbar, sondern er
bedeutet gleichsam, daß alles, was in Mathematica berechnet wird, als Objekt angesehen
werden kann.
Daraus folgt, dass sowohl der Input als auch der Output von Operationen und
Algorithmen Objekte sind und dadurch der Output eines Algorithmus der Input eines
anderen sein kann (sofern die geforderten Typen übereinstimmen)
Um beim Beispiel zu bleiben, muss im ersten Schritt angegeben werden, welche Pakete
bzw. Templates für den „Mathematica-Kernel“ benötigt werden, damit er die folgenden
MLF-spezifischen Datentypen, Operationen und Algorithmen interpretieren kann.
Dafür müssen folgende Codezeilen dem Mathematica-Kernel durch gleichzeitiges
Drücken der Tasten „Shift“ und „Enter“ übergeben werden.
Alle Operationen, die der Kernel ausführen soll, müssen ihm mit dieser Prozedur
übergeben werden. Es ist aber möglich, nicht jeden einzelnen Befehl so ausführen zu
lassen, sondern mehrere Befehle zu sammeln, und sie erst dann dem Kernel zu
übergeben.
Um das Beispiel grafisch aufarbeiten zu können, muß ein Grafikpaket hinzugeladen
-34-
werden, ebenso natürlich das Template MLF:
Needs["Graphics`Graphics`"] Needs["MLF`"]
„Needs“ ist der Befehl, der den Kernel anweist, die benötigten Files hochzuladen, welche
notwendig sind um die kommenden Angaben von Operationen und gegebenenfalls Typen
interpretieren zu können. Die Grundform der Befehlszeile sieht folgendermaßen aus:
Needs ["context`", "file"]
wobei [“context`“] den passenden Kontext angibt und, soweit dem Kernel dieser bekannt
ist, auch ausreicht, es sei den, es überlappen sich Namensbereiche bzw. Kontextangaben.
Falls Überlappungen bestehen, sorgt die Angabe des zweiten Parameters [„…file“] für
Klarheit, die den Dateinamen des „zu ladenden“ Paketes bzw. Bibliothek für den
Mathematica-Kernel angibt.
Damit wurde dem Mathematica-Kernel mitgeteilt, dass er einerseits alle Operationen und
notwendigen Algorithmen für den Kontext „Graphics“ aus dem Paket „Graphics“ laden
soll.
Um alle MLF spezifischen Operationen, Datentypen und Algorithmen für den
Mathematica Kernel verständlich zu machen, muss natürlich auch das Paket „MLF“
hochgeladen werden.
Durch das Installationsprogramm sollte eigentlich die MLF Bibliothek am richtigen Platz
installiert worden sein, so dass es Mathematica anfinden und laden kann.
Falls es diesbezüglich Probleme gibt, kann der Befehl
Links[]
darüber Aufschluss geben, welche Pakete in den Mathematica-Kernel aktuell
eingebunden beziehungsweise geladen sind. Die grafische Ausgabe sollte in etwa so
aussehen:
{LinkObject[47b,1,1], LinkObject
[C:\PathtoMathematica\AddOns\Applications\MLF\MLF.exe,2,2]}
Damit sollte sichergestellt sein, dass der Mathematica-Kernel, welcher eigentlich ein
„spezialisierter“ Compiler ist, die Typangaben und Operationsaufrufe korrekt und richtig
ausführen kann.
Somit ist die richtige Umgebung zur Erzeugung geeigneter Datenobjekte geschaffen
worden, damit man die geeigneten Datenobjekte erzeugen kann. Um die gewünschten
Daten in den Kernel zu laden, gibt es, wie bereits erwähnt, zwei Möglichkeiten:
-35-
Einerseits sind sie per Hand einzugeben, andererseits aus einem „File“ zu importieren.
Daten aus einem „File“ zu importieren ist besonders interessant bei Datensätzen, welche
in Datenbanken jeglicher Art gespeichert sind. Dabei ist Mathematica selbst sehr
vielseitig, da es sehr viele Formate unterstützt. Um bei dem Beispiel zu bleiben, muss
zunächst das entsprechende „File“ in den Mathematica-Kernel hochgeladen werden.
Damit das File von Mathematica gefunden werden kann, existiert eine Datei namens
„../data“ im Verzeichnis „MLF“. Alle dort befindlichen Datenfiles müssen nur mit ihrem
Namen und ihrer Dateiextension, sprich Dateitypangabe (z.B. *.txt), hochgeladen
werden, ohne den genauen Pfad zur Datei angeben zu müssen. Das Verzeichnis „.../data“
befindet sich unter:
„Laufwerksbuchstabe:\Pfad_zu_Mathematica_und_Version\AddOns\Applications\MLF\
Data“
Die Befehlszeile für das Beispiel lautet:
dataRaw=Import["iris.txt","Table"];
Damit wird das File „iris.txt“ in den Kernel importiert. Die Angabe der Option „Table“
ist optional und kann weggelassen werden, sofern es sich um ein Mathematica-Format
handelt, sonst muss der Typ angegeben werden.
Da die Daten des Beispiels in keinem Mathematica-Format vorliegen, sondern in einer
Tabelle, muss die „Import“-Operation von Mathematica angewiesen werden, dass sie das
File namens „iris.txt“ als Tabelle interpretieren soll.
Das importierte File soll unter dem Namen „dataRaw“ dem Mathematica-Kernel bekannt
sein.
Dies alleine reicht noch nicht aus, um die Daten bearbeiten zu können oder besser gesagt
interpretieren zu können.
Um dies tun zu können, muss dem Kernel ebenso mitgeteilt werden, wo er die Attribute
und die Ausprägungen zu den Attributen finden kann.
Dafür werden wieder Variablen angelegt, welche dieses Mal aber als Inhalt einerseits die
Merkmale andererseits die Ausprägungen dazu besitzen.
Um eine Variable anzulegen, die als Inhalt nur die Merkmalsarten besitzt, muss die im
Beispiel erste Zeile aus dem importierten File, also dem Datenobjekt „dataRaw“,
ausgelesen und einer Variablen zugewiesen werden.
Dafür sorgt die Angabe und Übergabe an den Mathematica-Kernel:
headers=First@dataRaw;
Mit dieser Befehlszeile wird vom Datenobjekt „dataRaw“ die erste Zeile ausgelesen.
Dies geschieht mittels der Operation „First“, welche die erste Zeile eines angegebenen
Datenobjektes (eigentlich eines Ausdruckes) ausliest und zurückgibt.
Angewandt wird diese Operation auf das Datenobjekt „dataRaw“ durch den ApplyOperator „@“ (, der die Schreibweise „Apply[function_name, expr]“ abkürzt auf die
-36-
Form „function_name@expression“).
Dem so ausgewerteten Ausdruck „First@dataRaw“ wird dann durch den Zuweisungsoperator „=“ der Name „headers“ zugewiesen.
Somit enthält das Datenobjekt „header “ die Merkmale der Beispielsdaten.
Im nächsten Schritt müssen die eigentlichen Daten, also die Merkmalsausprägungen zu
den Merkmalen, auch in einem Datenobjekt verpackt werden.
Dafür bietet sich die gleiche Vorgehensweise, an wie sie schon bei den Merkmalen
(„headers“) zum Ziel führte:
data=Rest@dataRaw;
Es werden wieder aus dem Datenobjekt „dataRaw“, dieses Mal aber mit der Operation
„Rest“, welche das gleiche „Verhalten“ wie die Operation „First“ besitzt, nur eben statt
der ersten Zeile den Rest ausgibt, die gewünschten Daten „herausgefiltert“ und dem
gewünschte Datenobjekt zugewiesen. In diesen Fall werden sie dem Datenobjekt mit
Namen „data“ zugewiesen.
Mittels der so definierten Datenobjekte ist es nun möglich ein Datenobjekt zu erstellen,
welches die bereits angelegten Objekte beinhaltet. Dieses Datenobjekt dient in weiterer
Folge als Grundlage für alle weiteren Verarbeitungsschritte und Berechnungen. Um nun
dieses Datenobjekt anzulegen, genügt die folgende Befehlszeile:
IrisData=Def["IrisData",DataSet[data,headers]];
In dieser Befehlszeile wird ein Datenobjekt mit dem Typ „DataSet“ kreiert:
DataSet[data, headers] Die Syntax für diese Operation, die eigentlich ein Konstruktor ist, lautet DataSet
[dataMatrix,opts].
Das heißt, die Operation „Dataset[]“ benötigt eine Matrix bestehend aus
Merkmalsausprägungen und optionalen Angaben. Unter die optionalen Angaben fallen
auch die Merkmale, welche bereits in dem Datenobjekt „headers“ aus dem File „iris.txt“
angelegt wurden.
Die Matrix der Merkmalsausprägungen beinhaltet die eigentlichen Daten und diese
befinden sich für das Beispiel schon im Datenobjekt „data“.
Im nächsten Schritt wird das eigentliche Datenobjekt, aus welchem die Informationen für
die Berechnungen stammen, angelegt. Dafür ist die Operation „Def“, ebenfalls ein
Konstruktor, verantwortlich, die aus dem Paket „MLF“ stammt, das eingangs in den
Kernel geladen wurde.
Def["IrisData",DataSet[data,headers]];
Als Input verlangt die Operation „Def []“ einen Namen für das Datenobjekt, welches
-37-
angelegt werden soll, für das Beispiel wäre dies der Name „IrisData“.
Das „Datenobjekt“, das als Input für die Operation „Def[]“ dienen soll, stammt von der
Operation „DataSet[]“, welche als verschachtelter Operationsaufruf anstelle des
Datenobjektes steht.
Das heißt, das Datenobjekt, welches als Input für die Operation „Def[]“ dient, hätte
durchaus schon vorher deklariert und definiert werden können. Aber diese
„Schreibweise“ ist eleganter und vor allem prägnanter.
Abschließend wird mittels des Zuweisungsoperators der Name „IrisData“ dem erzeugten
Objekt aus der Operation „Def[]“ (respektive der Operation „DataSet[]“) zugewiesen.
Um das Erzeugen und Aufbereiten der Daten für den Mathematica-Kernel abschließen zu
können, sollten alle nicht mehr benötigten Datenobjekte gelöscht werden.
Es sei ausdrücklich darauf hingewiesen, dass dieser Schritt optional ist und eigentlich in
keiner Weise die Auswertung der Daten beeinflusst. Jedoch ist es angesichts dessen, dass
die zu bearbeiteten Datenmengen „sehr groß“ werden können, ratsam, die nicht
benötigten Datenobjekte zu löschen um somit Ressourcen nicht unnotwendigerweise zu
belegen.
Um beim Beispiel zu bleiben, können das Datenobjekt „dataRaw“, also das eingelesene
„iris.txt“-File, sowie das Datenobjekt „data“, sprich die extrahierten
Merkmalsausprägungen aus dem Datenobjekt „dataRaw“, gelöscht werden. Die folgende
Befehlszeile gewährleistet dies:
Clear[dataRaw,data];
Das heißt, die alleinige Angabe der Operation „Clear[]“ (Destruktor) und der Name der
Datenobjekte, getrennt durch ein Komma reichen aus.
Somit wäre die Erzeugung der Datenobjekte, welche im ausreichenden Maße für den
Mathematica Kernel aufbereitet sind, und eine passende Arbeitsumgebung für MLF
vorhanden.
-38-
6.2.2 Attribut-Matrix Plott des Datenobjektes
Als Nächstes können die möglichen Merkmalsausprägungen des Zielattributes
ausgegeben werden. Dadurch ist es möglich, sich ein Bild über das Zielattribut zu
machen, beziehungsweise welche Entscheidungen die „zu entstehende“ Regelbasis
leisten sollte.
Um die Ausgabe der Merkmalsausprägungen des Zielattributes bewerkstelligen zu
können werden drei Funktionen benötigt, die im folgenden beschrieben werden.
Wie in den vorigen Abschnitten beschrieben greifen sie ineinander und verwenden das
Ergebnis einer vorherigen Operation als ihrem eigenen Input.
Zuerst muss das Datenobjekt, welche das Zielattribut und die Merkmalsausprägungen
besitzt, angegeben werden. Danach sollten aus dem Datenobjekt die richtige Spalte
ausgesucht und alle möglichen Prädikate extrahiert werden.
Für diese Aufgabe existiert bereits eine Funktion namens:
CreatePredicates [dataSet,rows,nrSets,opts].
Diese Operation erstellt aus einem Datenobjekt unter der Angabe des gewünschten
Merkmales des Objektes alle möglichen Prädikate.
In dem Beispiel heißt das Datenobjekt „IrisData“, und die fünfte Spalte ist das
gewünschte Zielattribut, das durch die anderen Attribute beziehungsweise eine
Regelbasis ausgedrückt werden soll.
Somit wäre der gesamte Ausdruck für die Extrahierung aller Ausprägungen des
Zielattributes:
CreatePredicatesIs[IrisData,5]
Damit alle Merkmalsausprägungen grafisch ausgegeben werden können, müssen sie
zuerst „geplotet“ werden. Beim Ploten2 wird aus den Prädikaten ein Plot erzeugt, welcher
unter der Angabe von verschieden Parametern, das Zielattribut beschreibt.
Wie schon erwähnt, dient die Funktion „CreatePredicatesIs[]“ als Input für die nächste
Operation, die den Plot vornimmt. Ihr Name ist:
PlotClassLegend [goalVars, options]
Die „Zielvariablen“ (Merkmalsausprägungen des Zielattributes)wurden bereits aus dem
Datenobjekt „IrisData“ herausgelesen und stehen somit zur Verfügung.
Unter den Optionen fällt die Angabe der Größe des Plots, also der Breite und der Höhe,
2 Plot = Grafik, in der gewünschte Objekte dargestellt werden (im weiteren Verlauf
häufig eine Grafik, in der alle Merkmalsausprägungen der Datensätze auf Achsen vorher
bestimmter Attribute eingetragen werden (jede Achse steht für ein Attribut))
-39-
sowie der Menge an „Merkmalsausprägungen, also ob alle Zielvariablen oder nicht in
den Plot aufgenommen werden sollen.
Für den Plot der Merkmalsausprägungen macht es Sinn, die Größe der Einträge des
Datenobjekts „IrisData“ auf 15 mm beschränken zu lassen, ebenso ist es sinnhaft, alle
Einträge ausgeben zu lassen.
Die Angabe der Option:
PlotRange >All
legt fest, dass alle Zielvariablen geplottet werden und die Angabe der Option:
AspectRatio > 0.15
bedingt, dass die geplotteten Zielvariablen durch 15 mm getrennt sind.
Ein Beistrich zwischen den Angaben der Optionen für die Operation „PlotClassLegend[]“
ist zwingend erforderlich, denn sonst erzeugt man einen „Syntax-Error“, welcher dadurch
entsteht, dass für den Mathematica Kernel „PlotRange -> ...“ und „AspectRatio ->..“
ohne Beistrich getrennt eine „Option“ wäre, und zwar „PlotRange -> … AspectRatio ->
…“ und nicht zwei, denn und diese Option existiert nicht.
Gesamt gesehen erzeugt die Angabe der Operation „PlotClassLegend[]“ mit den
gewünschten Parametern für das Beispiel den geforderten Plot. Die Angabe der
Operation für den Kernel sieht so aus:
PlotClassLegend[CreatePredicatesIs[IrisData,5]],PlotRange > All,AspectRatio > 0.15
Jetzt muss der Plot nur mehr grafisch ausgegeben werden, damit man ein Ergebnis des
bisherigen Aufwandes sehen kann.
Die Operation „Show[]“ kann diese Aufgabe übernehmen:
Show[graphics, options]
Die Angabe von Parametern wird bei diesem Beispiel nicht benötigt und kann
dementsprechend weggelassen werden.
Die Operation „Show[]“ benötigt allerdings ein Objekt des Typs „Graphics“ als Input.
Folglich muss der Plot zu dem Typ „Graphics“ konvertiert werden.
Die Funktion „Graphics[]“:
Graphics[primitives, options]
übernimmt die Konvertierung, welche im eigentlichen Sinne keine ist. Der Typ
„Graphics“ repräsentiert nämlich in Mathematica ein zu „zeichnendes Objekt“, welches
auf einer Menge von „primitves“, also „Grundarten“, basieren muss. In Mathematica
wäre zum Beispiel der Kreis ein solches „primitive“, durch „MLF“ wurde diese Menge
erweitert, sodaß auch „PlotclassLegend[]“ dazuzählt.
Eine mögliche optionale Angabe wäre zum Beispiel die Angabe der
„Achsenbenennungen“.
-40-
Graphics[PlotClassLegend[CreatePredicatesIs[IrisData,5]],PlotRange > All, AspectRatio >
0.15]
Die obere Angabe der Operation „Graphics[]“ mit diesen Input generiert das fertige
„Graphic-Datenobjekt“, welches die gewünschten Zielvariablen und Parameter enthält.
Dieses „Graphic-Datenobjekt“ muss nur mehr dargestellt werden. Wie bereits erwähnt,
übernimmt die Operation „Show[]“ diese Aufgabe und gibt das „Graphic-Datenobjekt“
auf den Bildschirm aus.
Die „Show[]“ Operation muss mittels „Apply“ Operators (@) auf das „GraphicDatenobjekt“ angewandt werden.
Die folgende Befehlszeile enthält alle Angaben für den Mathematica-Kernel, damit er die
von Beginn an angestrebte Aufgabe des grafischen Darstellens aller
Merkmalsausprägungen des Zielattributes realisieren kann:
Show@Graphics[PlotClassLegend[CreatePredicatesIs[IrisData,5]],PlotRange > All ,
AspectRatio >0.15];
Nach Ausführung dieser Anweisung sieht der Output wie folgt aus, wobei den
geplotteten Zielvariablen auch Farben von Mathematica zur leichteren Identifizierung
zugeordnet werden.
class_Is _Iris - setosa
class_Is _Iris - versicol
class_Is _Iris - virginica
Weiters ist es sinnvoll, die Attribute und ihre Ausprägungen gegeneinander zu ploten,
sprich eine „Attribut-Matrix“ zu erzeugen und sie grafisch ausgeben zu lassen.
Der Sinn liegt darin, dass dadurch leichter ersichtlich wird, inwiefern gewisse Attribute
das Zielattribut erklären können, sprich inwieweit sich die Merkmalsausprägungen bei
den einzelnen Attributen bezüglich der Zugehörigkeit zu den Zielvariablen manifestieren.
Dies wird dann ersichtlich, wenn sich beim Plot „regelrechte“ Gruppen von
gleichfärbigen Merkmalsausprägungen bei der Grafik bilden (,sofern die
Merkmalsausprägungen die gleichen Farben haben, gehören sie zu Datensätzen, die die
gleiche Merkmalsausprägung wie das Zielattribut besitzen.)
Dieser Schritt ist mehr oder weniger optional, denn wenn bereits bei der Sichtung der
Daten bezüglich des Zielattributes eine klare Klassifizierung anhand der Ausprägungen
der anderen Attribute feststellbar ist, kann dieser Verarbeitungschritt übersprungen
werden.
In den meisten Fällen wird dies in den Ausgangsdaten nicht ersichtlich sein, und man
benötigt eine „bessere“ Darstellung dessen in grafischer Form. Diese „bessere“
Darstellung ist der Plot der „Attribut-Matrix“.
-41-
Die Vorgangsweise ist bei diesem Schritt relativ simpel, denn die Benennung des
richtigen Datenobjektes, die Angabe aller benötigter Parameter wie zum Beispiel der
Zielvariable und die grafische Ausgabe reichen dafür vollkommen aus.
Da es sich um einen Plot handelt, wird eine Operation benötigt, die eine „AttributMatrix“
überhaupt plotten kann.
Diese Operation wird von MLF eingeführt und heißt „PlotAttributeMatrix []. Der Syntax
sieht wie folgt aus:
PlotAttributeMatrix [data,options];
Als Eingabe verwendet diese Operation ein Datenobjekt, welches Merkmale und die dazu
passenden Merkmalsausprägungen besitzt.
Das am Anfang angelegte Datenobjekt „IrisData“ wurde bereits so aufbereitet, dass in der
ersten Zeile die Namen der Merkmale stehen und in den Reihen darunter deren
Ausprägungen.
Somit reicht die Angabe des Datenobjektes „IrisData“ vollkommen aus, es muss keine
Aufarbeitung oder Extrahierung der Daten mehr vorgenommen werden.
Einzig die Angabe der Zielvariable, besser gesagt die Definition welche der Attribute des
Datenobjektes „IrisData“ die Zielvariable ist, wird benötigt mit der folgenden
Optionsangabe erledigt:
Goal > 5
Weiters ist die Angabe der Punktgröße des Plottes sinnhaft, da der Standardwert sehr
klein eingestellt ist und somit eine optische Unterscheidung schwerfallen kann.
Für das Beispiel wäre eine Größe von 3 bis 4 mm ausreichend, um die Grafik
aussagekräftig zu gestalten.
Mit der Optionsangabe:
PointSize > 0.03
wird die Größenangabe vorgenommen.
Der gesamte Ausdruck zur Generierung eines „Attribut-Matrix-Plotes“ für das Beispiel
hat die folgende Form:
PlotAttributeMatrix[IrisData,Goal > 5,PointSize > 0.03]
Damit dieser Ausdruck grafisch dargestellt werden kann, kann man wiederum die „Show
[]“ Operation benutzen.
Mittels des „Apply-Operators“ (@), angewandt auf den Ausdruck zur Generierung des
Plottes der „Attribut-Matrix“ des Datenobjektes „IrisData“, wird eine Grafik erzeugt,
welche die Daten grafisch darstellt:
Show[PlotAttributeMatrix[IrisData,Goal > 5,PointSize > 0.03]];
-42-
Das Ergebnis der Auswertung der Anweisung durch Mathematica erzeugt für das
Beispiel folgende Grafik:
sepal_length
sepal_width
petal_length
petal_width
class
In dem Matrix-Attribut-Plot ist ersichtlich, dass durch die Attribute 3 und 4 die
Zielvariable, welche im Datenobjekt die Nummer 5 ist, „ausdrückbar“ ist.
Unter „ausdrückbar“ ist zu verstehen, dass eine Klassifizierung, sprich eine Zuordnung
der möglichen Merkmalsausprägungen der Zielvariable anhand der
Merkmalsausprägungen der anderen Attribute, besser gesagt anhand dessen
Ausprägungen, möglich ist.
Da die Grafik doch sehr klein ist und auch nur der Übersicht dient, wäre es sehr sinnvoll,
nur bestimmte Attribute gegeneinander zu plotten.
Dies ist ohne weiteres in Mathematica möglich und führt zu Schritt drei in der am Anfang
eingeführten Vorgehensweise von „Supervised Learning“.
-43-
6.2.3 Grafische Skizzierung der Attribut-Matrix
Im letzten Abschnitt wurde ein „Attribut-Matrix-Plot“ generiert und geplotet. Dabei wird
keine Matrix aus einer Menge von Attributen, sondern lediglich zwei Attribute (wenn
erwünscht auch drei oder mehr), gegeneinander geplottet.
Es sind deswegen zwei Attribute, weil die Darstellung in einem kartesischen Diagramm
erfolgt und somit nur zwei Achsen vorhanden sind. Dennoch wird dadurch die Grafik
sehr aussagekräftig. Es könnte auch dreidimensional oder gar mehrdimensional geplottet
werden, dies hängt einerseits davon ab, wie viele Attribute benötigt werden, um die
Zielvariable zu klassifizieren, andererseits davon, wie die Attributmatrix geplottet wurde.
Bei diesem Beispiel ergibt ein Plot von mehr als zwei Dimensionen weniger Sinn, da
bereits zwei Attribute ausreichend sind, das Zielattribut zu beschreiben.
Um einzelne Attribute zu plotten, wurde in MLF eine Operation definiert, die diese
Aufgabe lösen kann.
Die Operation heißt „PlotAttributes[]“ und ihr Syntax lautet wie folgt:
PlotAttributes [data,options];
Als Input verlangt diese Operation ein Datenobjekt, in welchem die Attribute enthalten
sind. Wie bei den vorigen Operationen enthält das Datenobjekt „IrisData“ alle
notwendigen Daten in aufbereiteter Form.
Bei der Operation „PlotAttributes[]“ müssen keine Informationen extrahiert werden, da
alle Merkmalsausprägungen gefordert sind.
Für das Beispiel reicht die Angabe von einigen Parametern aus, um den Plot in
gewünschter Form durchführen zu lassen.
Alls Erstes muss angegeben werden, aus welchen Datenobjekt überhaupt etwas
„herausgelesen“ werden soll. Bei dem Beispiel wäre es das Datenobjekt Namens
„IrisData“ und mit der Angabe von:
IrisData,
an der ersten Stelle des Inputs der Operation „PlotAttributes[]“ wird dies auch erledigt.
Als zweiter Schritt muss der Operation mitgeteilt werden, welche Attribute überhaupt
geplottet werden sollen. Da die Merkmalsausprägungen im Datenobjekt „IrisData“ in
Tabellenform vorliegen, reicht die Angabe der Spalten, in denen sich die
Merkmalsausprägungen zu den Attributen befinden, aus.
Im Beispiel wären dies die Spalten, drei und vier. Durch die Angabe des folgenden
Parameters der Operation „PlotAttributes[]“ wird dies erledigt:
Dims > {3,4},
Um festzulegen, welches Attribut überhaupt geplottet werden soll, gibt man bei den
Optionen der Operation „PlotAttributes []“ die folgende Option an:
-44-
Goal > 5,
Damit wird sichergestellt, daß gegen das gewünschte Zielattribut geplotet wird, wobei
dieser Parameter teilweise schon in den Operationen der vorigen Arbeitschritte verwendet
wurde.
Abschließend ist es noch sinnvoll, die Ausgabe der Merkmalsausprägungen im Plot zu
verändern. Möglich sind zum Beispiel die Größe der Punkte im Plot, aber auch deren
Farben. Welcher Wert für die Größe der Punkte sinnhaft ist und welcher nicht, hängt sehr
stark von der Menge der Daten ab. Für das Beispiel macht eine Punktgröße von etwa 2
bis 3 mm Sinn. Mit dem folgenden Parameter wird die Größe der Punkte im Plot auf 2,5
mm eingestellt:
PointSize > 0.025
Gesamt sieht die Operation für das Ploten aller Merkmalsausprägungen der Merkmale 3
und 4 gegen das Zielattribut 5 wie folgt aus:
PlotAttributes[IrisData, Dims > {3,4}, Goal > 5, PointSize > 0.025 ]
Um dies grafisch darstellen zu können, muss wieder die Operation „Graphics[]“ auf den
Plot angewendet werden. Damit wird erneut ein Objekt generiert, welches überhaupt erst
über die Operation „Show[]“ Verwendung finden kann.
Um dies zu erreichen, wird als „Input-Datenobjekt“ für die Operation „Graphics[]“ der
Ausdruck:
PlotAttributes[IrisData, Dims > {3,4}, Goal > 5, PointSize > 0.025 ]
genutzt. Für das optische Aussehen des Plots wären ein Name für den Plot und
Achsenbeschreibungen von Interesse, außerdem sollten alle Achsen angezeigt und keine
weggeschnitten werden.
Damit alle Achsen angezeigt werden, reicht die Angabe des folgenden Parameters für die
Operation „Graphic[]“ vollkommen aus:
Axes > True
Um die Beschriftung der Achsen zu ermöglichen, genügt der folgende Parameter:
AxesLabel > headers[[{3,4}]]
wobei dieser Parameter ein Ausdruck ist, in welchem die Namen für die X und die YAchse aus dem Datenobjekt „headers“ (beinhaltet die Namen der Attribute) festgelegt
wird. Der Operator „->“ nimmt die Zuweisung vor und durch die Angabe von:
-45-
headers[[{3,4}]]
werden das dritte und vierte Element vom Datenobjekt „headers“ angesprochen.
Zum Schluss fehlt nur noch der Name des Plottes, wobei bemerkt sei, dass dies wirklich
nur optional ist und absolut nichts zur Berechnung beiträgt, genauso wie die
Achsennamen des Plottes.
Trotz allem wird der Name des Plots über den gleichen Weg gesetzt, wie die
Achsennamen:
PlotLabel > headers[[5]]
Der Zuweisungsoperator „->“ übernimmt die Zuweisung und mit dem Aufruf des
Datenobjektes „headers“ und der Angabe des fünften Elementes wird der Name des
Zielattributes der Variablen „PlotLabel“ zugewiesen.
Der gesamte Ausdruck sieht für dieses Beispiel wie folgt aus:
Graphics[PlotAttributes[IrisData,Dims > {3,4},Goal > 5,PointSize > 0.02]],Axes > True,
AxesLabel > headers[[{3,4}]],
PlotLabel > headers[[5]];
wobei die Funktion „Graphics“ dieses Mal nicht durch den „Apply-Operator“ (@) auf
das von „PlotAttributes[]“ erzeugte Datenobjekt angewandt wird, sondern durch einen
„normalen“ Operationsaufruf der Form „Graphics[…] „ . Verantwortlich dafür ist die
Übersichtlichkeit, da dies in einer solchen Form durch die vielen optionalen
Parameterangaben eindeutiger ist und Fehlinterpretationen des Benutzers bei einer
späteren Durchsicht vorbeugt.
Abschließend muss das so erzeugte „Graphic-Objekt“ nur mehr grafisch ausgegeben
werden. Mit der Operation „Show[]“ wird das erreicht.
Die gesamte Befehlszeile sieht so aus:
Show[Graphics[PlotAttributes[IrisData,Dims > {3,4},Goal > 5,PointSize > 0.02]],Axes >
True, AxesLabel > headers[[{3,4}]],
PlotLabel > headers[[5]]];
-46-
Dadurch wird erreicht, dass ein Plott der Attribute drei und vier gegen das Zielattribut
erzeugt und grafisch ausgegeben wird. Der Output sollte wie folgt aussehen:
petal_width
2.5
class
2
1.5
1
0.5
1
2
3
4
5
6
7
petal_length
6.2.4 Definition von Fuzzy-Sets
Um sich ein Bild machen zu können, wie eine Klassifizierung des Zielattributes (im
Beispiel die Unterart der Pflanze) nicht anhand der klassischen Logik sondern unter
Verwendung der Fuzzy-Logik aussehen würde, muss man geeignete Fuzzy-Sets
definieren.
Die Idee ist folgende: alle Pflanzen, von denen Merkmalsausprägungen zu den
vorgegebenen Attributen ermittelt werden können, anhand der Fuzzy-Sets für die
Attribute drei und vier bezüglich dem Attribut fünf (Zielattribut = Unterart der Plfanze)
zu bewerten.
Die Einteilung erfolgt zuerst in einer Einfärbung aller Merkmalsausprägungen der
Attribute in einem Plot, wie er im Schritt drei erzeugt wurde. Damit wird „ungefähr“
ersichtlich, inwieweit sich die Daten kategorisieren lassen.
Um nun so einen Plot erzeugen zu können müssen zuerst die geeigneten Fuzzy-Sets
erzeugt werden.
Je nachdem wie viele Attribute das Zielattribut „erklären“ sollen, müssen auch FuzzySets angelegt werden.
Für das Beispiel genügen exponentielle Fuzzy-Sets. Die Operation zur Erzeugung eines
Fuzzy-Sets lautet:
FuzzySetExp [center, width];
Die Operation verlangt als Input die Angabe des Zentrums und der Breite des Fuzzy-Sets.
Bei der Betrachtung der Daten für das Beispiel fällt auf, dass für das Attribut drei
(petal_length) die dokumentierten Pflanzen bis zum Wert fünf und ab dem Wert 6 sehr
gut klassifizierbar sind, dazwischen existieren jedoch immer wieder Pflanzen, die nicht
eindeutig einer Menge zugeordnet werden können.
Also muss das „Zentrum“ des neuen Fuzzy-Sets für das Attribut drei (petal_length) bei
-47-
5,5 cm liegen. Die Breite des Fuzzy-Sets sollte auf beiden Seiten des Zentrums zwischen
0,3 cm und 0,4 cm liegen, denn in diesem Bereich befinden sich Pflanzen mit
Merkmalsausprägungen zum Attribut drei (petal_length), welche nicht eindeutig einer
Merkmalsausprägung vom Zielattribut zu geordnet werden können.
Mittels des Zuweisungsoperator „=“ und der vorigen Angabe eines Namen für das neue
Fuzzy-Set wird es mit dem folgenden Ausdruck als Datenobjekt angelegt:
fuzzysetforcollum3= FuzzySetExp[5.5,0.3];
Für das Attribut vier (petal_width) gilt diesselbe Vorgangsweise.
Beim Attribut vier liegt der für die klassische Logik unentscheidbare Bereich für eine
Zuordnung zu einer Menge im Bereich der Werte 1,65 und 1,85 cm. Daraus folgt, dass
ein exponentielles Fuzzy-Set mit dem Zentrum bei 1,75 cm und einer Breite von 0,05 cm
diesen Bereich abdecken würde. Das Fuzzy-Set für das Attribut vier (petal_width) wird
wieder mit dem Aufruf der Operation „FuzzySetExp[]“ und dem Zuweisungsoperator
„=“ mit einem Namen generiert:
fuzzysetforcollum4 =FuzzySetExp[1.75,0.05];
Optional gibt es auch eine Operation, welche die gewünschten Fuzzy-Sets grafisch
ausgibt, die Operation lautet;
PlotFuzzySet[fuzzy-set, options];
Für beide Fuzzy-Sets erzeugen die folgenden Befehlszeilen,
PlotFuzzySet[fuzzysetforcollum3];
einen Output der wie folgt aussieht:
1
0.8
0.6
0.4
0.2
4.5
5.5
6
6.5
-48-
1
0.8
0.6
0.4
0.2
1.7
1.8
1.9
Weiters muss für jedes Attribut das passende Prädikat aus dem dazugehörenden FuzzySet erzeugt werden. Die Funktion „FColPredIsAl[]“ generiert die passenden Prädikate
anhand der Angabe des Attributes und eines Fuzzy-Sets:
FColPredIsAl[col, fuzzySet]
Mit den folgenden zwei Befehlszeilen werden die passenden Prädikate für die Attribute
drei und vier erzeugt:
fuzzypredicateforcollum3 = FColPredIsAL[3,fuzzysetforcollum3];
Für eine Einteilung der Wertemengen der Attribute drei und vier reichen die Prädikate
nicht aus; sie müssen erst in Beziehung zu einander gebracht werden. Bei diesem
einfachen Beispiel reicht eine Fuzzy-Disjunktion vollkommen aus. Die Operation „FOr
[]“ erzeugt diese Disjunktion für das Beispiel:
FOr[arg1, arg2] oder FOr[arglist]
Aus dem Syntax der Operation folgt, dass man entweder zwei Argumente (eigentlich
Prädikate) an gibt oder gleich eine gesamte Liste davon (dies bekommt erst bei
komplexere Aufgaben eine Bedeutung).
Für das Beispiel wurden bereits die Datenobjekte für die beiden Prädikate der Attribute
drei und vier angelegt. Die Anwendung der Funktion „FOr[]“ auf diese beiden Prädikate:
curSelection=FOr[fuzzypredicateforcollum3, fuzzypredicateforcollum4];
erzeugt die passende Fuzzy-Disjunktion für das Beispiel. Im nächsten Schritt wird diese
Disjunktion auf die vorhanden Daten angewandt. Danach wird ersichtlich, inwieweit eine
Einteilung mit den definierten Fuzzy-Sets möglich ist. Die gesamte Befehlsauflistung für
diesen Verarbeitungsschritt sieht wie folgt aus:
fuzzysetforcollum3= FuzzySetExp[5.5,0.3];
fuzzysetforcollum4 =FuzzySetExp[1.75,0.05];
-49-
curSelection=FOr[fuzzypredicateforcollum3, fuzzypredicateforcollum4];
6.2.5 Grafische Skizzierung der Attribut-Matrix mit Einbeziehung
von Fuzzy-Sets
Nach der Definierung der passenden Fuzzy-Sets für die ausgewählten Attribute, (im
Beispiel für die Attribute drei und vier)können diese grafisch geplottet werden, (so wie es
bereits im Schritt drei und vier gehandhabt wurde). Dadurch wird ersichtlich, wie passend
die Fuzzy-Sets definiert wurden und inwiefern sie einer Klassifizierung des Zielattributes
dienlich sind.
Um dieses Vorhaben realisieren zu können, bietet sich einerseits ein Plot für die Attribute
drei und vier an, andererseits ein Matrix-Attribut Plot mit allen Attributen.
Zu einem übersichtlicheren Plot kommt es, wenn man die Fuzzy-Sets in einem Plot für
ausgesuchte Attribute miteinbezieht. Deswegen sollte auch zuerst der Plot für die
ausgesuchten Attribute beschrieben werden. Wie es zu einem solchen Plot kommt wurde
bereits im Schritt vier der Vorgehensweise von „Supervised Learning“ beschrieben,
weswegen dieser Punkt nur sehr kurz behandelt wird.
Wie im Schritt vier beschrieben, müssen wieder Attribute geplotet werden. Die dafür
zuständige Operation lautet wieder:
PlotAttributes [data,options];
Als Input bzw. als Grundlage zur Berechnung des Plotes dient das Datenobjekt
„IrisData“. Die Attribute drei und vier, (also die Spalten drei und vier) sollen geplotet
werden. Anders als im Schritt vier, ist das Ziel des Plots nicht mehr das Zielattribut,
sondern die Fuzzy-Disjunktion, welche die Fuzzy-Sets und das Zielattribut enthalten.
Die Größe der geploteten Merkmalsausprägungen pro Datensatz können bei diesem
Beispiel bei etwa 2,5 mm liegen:
PlotAttributes[IrisData, Dims > {3,4},Goal > curSelection, PointSize > 0.025]
Die Angabe des Namens des Datenobjektes, gefolgt von der Auswahl der Spalten des
Datenobjektes:
Dims > {3,4}
und des Zielattributes, im Beispiel die Fuzzy-Disjunktion:
Goal > curSelection
-50-
sowie der Größe der Elemente des Plotes:
PointSize > 0.02
erstellen einen Plot, der die zuvor erstellte Fuzzy-Disjunktion enthält und danach auch
plotet.
Jetzt muss nur mehr das „Graphic“ Datenobjekt erzeugt werden, bevor es grafisch
ausgeben werden kann. Dafür reichen wieder die Überlegungen aus, wie die Benennung
der Grafik beziehungsweise der Achsen lauten, und ob alle oder nur einige Achsen
ausgegeben werden sollen.
Für das Beispiel wäre es natürlich wünschenswert, wenn alle möglichen Achsen erzeugt
und ausgegeben werden:
Axes > True
Die Achsenbeschriftungen können wieder aus dem Datenobjekt „headers“ herausgelesen
werden. Mittels der Angabe des Datenobjektes und der Auswahl der Elemente drei und
vier sowie der Zuweisung zu den Achsennamen durch den „->“ Operator, wird diese
Aufgabe von Mathematica erledigt:
AxesLabel > headers[[{3,4}]]
Es fehlt nur noch der Name der Grafik, welcher einfach durch die Angabe eines Strings
angeführt von „“ und durch den „->“ Operator zu der Variable „PlotLabel“ zugewiesen
werden kann. Die Variable „PlotLabel“ kommt von der Operation „PlotAtributes[…]“
und wird bei dessen Ausführung zu der Grafik zugeordnet:
PlotLabel > "Iris flowers"
Um die Grafik auch sehen zu können, muss das generierte „Graphic“ Objekt ausgeben
werden.
Es sei an dieser Stelle vermerkt, daß nicht wirklich ein „Graphic-Objekt“ existiert. Es
wird in Mathematica nur dann ein neues Objekt angelegt, wenn es mit dem
Zuweisungsoperator „=“ einer Variablen, besser gesagt einem Namen zugewiesen wird,
sonst ist es nur ein Ausdruck, welcher beim Aufruf ausgewertet wird. Die Auswertung
findet von Innen nach Außen statt, das heißt der innerste Aufruf einer Operation
beziehungsweise Funktion wird ausgewertet und dient als Input für die „umschließende“
nächste Operation beziehungsweise Funktion. Dadurch ist es möglich, einen sehr
kompakten Code in Mathematica zu schreiben, da das Anlegen von Datenobjekten in den
meisten Fällen weggelassen werden kann, es sei denn diese Art von Ausdruck sollte des
öfteren ausgewertet werden, wie zum Beispiel das Datenobjekt „headers“. Durch solche
Maßnahmen werden sowohl Speicherplatz als auch Rechenzeit gespart.
Um die Grafik ausgeben zu lassen wird wieder die Funktion „Show[]“ verwendet. Diese
-51-
wird wiederum durch den „Apply-Operator“ auf das “Graphic“ Datenobjekt angewandt
und erzeugt einen grafischen Output des Kernels.
Mit der folgenden Befehlszeile ist der erste Teil des Schrittes fünf abgeschlossen:
Show[Graphics@PlotAttributes[IrisData,Dims > {3,4},Goal\[Rule]curSelection, PointSize >
0.02], Axes > True,AxesLabel > headers[[{3,4}]],PlotLabel > "Iris flowers"]
Der Output von Mathematica beschreibt auch schon die Erwartungen in die Fuzzy-Sets,
die zuvor generiert wurden und sieht folgendermassen aus:
petal_width
Iris flowers
2.5
2
1.5
1
0.5
1
2
3
4
5
6
7
petal_length
Durch die Grafik wird ersichtlich, dass im Grenzbereich, in dem die klassische Logik
nicht mehr im Stande wäre eine Einteilung zu treffen, die Fuzzyfizierung eine sehr gute
Klassifizierung bietet; nur einige Datensätze sind noch nicht eindeutig einteilbar.
Als nächsten Schritt wäre es vorteilhaft, einen gesamten Matrix-Attribut Plott unter der
Einbeziehung der Fuzzy-Sets zu erstellen.
Dieser Teil des Schrittes vier sei nur sehr kurz umschrieben, da er bereits behandelt
wurde.
Mit der Operation „PlotAttributeMatrix[]“, mit der zusätzlichen Angabe der zu plotenden
Spalten, des Zieles (für das Beispiel die Fuzzy-Disjunktion), der Punktgröße sowie der
Operation „Show[]“ :
Show@PlotAttributeMatrix[IrisData,Dims > Range[4],Goal > curSelection, PointSize >
0.03];
wird ein solcher Matrix-Attribut Plot erzeugt und grafisch ausgegeben:
-52-
sepal_length
sepal_width
petal_length
petal_width
Dadurch wird ersichtlich, inwieweit eine Einteilung in den Grenzfällen bezüglich aller
Attribute und Datensätze möglich ist. Wenn die Ergebnisse der Datenverarbeitung bis
hierher erfolgreich waren und ebenso zufriedenstellend sind, ist eine weitere
Verarbeitung erfolgsversprechend. Die bisherigen Verarbeitungsschritte dienten
hauptsächlich der näheren Betrachtung der Daten und nicht einer direkten Auswertung
im Sinne von „Data Mining“.
Da die bisherigen Ergebnisse, wie schon erwähnt, erfolgreich waren, kann im nächsten
Schritt für das Beispiel eine Regelbasis erstellt werden.
6.2.6 Erzeugung eines „Decision-Trees“
Da es das Ziel ist, von den Attributen drei und vier auf das Zielattribut zu schließen,
bietet sich ein Entscheidungsbaum an, um dies zu erreichen. Der implementierte FS-ID3Algorithmus ist imstande, einen solchen Entscheidungsbaum zu generieren.
Für das Beispiel wurden die Daten bereits aufgearbeitet und in Datenobjekten angelegt,
damit ist die richtige Arbeitsumgebung für die Algorithmen vorhanden, um mit ihnen
„Data Mining“ durchführen zu können.
Die vorherigen Definitionen von Fuzzy-Sets haben gezeigt, daß eine Klassifizierung
durch sie erfolgsversprechend ist. Die Fuzzy-Sets werden in den FS-ID3-Algorithmus
bzw. den von ihm erstellten Entscheidungsbaum dadurch miteinbezogen, daß die
Entscheidung, zu welchen weiteren Knoten von der Wurzel aus gegangen wird, von
Kanten abhängt. Alle Kanten, die zu einem Knoten führen, können durch Fuzzy-Sets
-53-
dargestellt werden, dass heißt die geeigneten Fuzzy-Sets geben Auskunft darüber, zu
welchem Knoten beziehungsweise Blatt gegangen wird.
Damit ein geeigneter Entscheidungsbaum generiert werden kann, müssen zuerst die
entsprechenden Prädikate, basierend auf Fuzzy-Sets, für alle Attribute erstellt werden. Es
ist weiters notwendig, Datenobjekte zu erschaffen, welche die passenden Variablen zu
den Prädikaten beinhalten!
Bei der Erstellung der Prädikate gibt es einen Unterschied, der darin liegt, dass die
Attribute eins bis vier numerischer Art sind, das Zielattribut jedoch nicht. Deswegen
werden ihre Prädikate von anderen Operationen erstellt.
Für die Erstellung der Prädikate müssen keine Fuzzy-Sets angegeben werden (können
aber wenn es vom Benutzer gewünscht wird), sie werden automatisch erstellt, und die
Angabe der Attribute reicht aus.
Für die Attribute eins bis vier gibt es die folgende Operation:
CreatePredicates[dataSet,rows,nrSets,opts];
Als Input verlangt diese Operation ein geeignetes Datenobjekt, für das Beispiel wäre es
das Datenobjekt “IrisData”. Weiters verlangt diese Operation die Angabe der Attribute,
die Anzahl der Fuzzy-Sets, die erstellt werden sollen, und noch verschiedene Optionen,
welche sich auf die Fuzzy-Sets beziehen (z.B.: Breite der Fuzzy-Sets).
Im Beispiel wäre das geeignete Datenobjekt „IrisData“. Die Spalten eins bis vier sind die
gewünschten numerischen Attribute und insgesamt sollen fünf Fuzzy-Sets daraus
generiert werden (für jedes Attribut Eines und für die Grenzfälle ebenfalls.)
testPreds=CreatePredicates[IrisData,{1,2,3,4},5];
Passend zu den Prädikaten sollten auch gleich die dazugehörigen Variablen erstellt
werden. Durch die folgende Funktion wird dies erreicht:
DefPredicateVars[predicateList];
Mit der Zuweisung zu einem Namen wird ein solches Datenobjekt angelegt. Die Angabe
der Prädikate als Input für diese Operation genügt, um diese Aufgabe zu erfüllen:
testVars=DefPredicateVars[testPreds];
Wie schon erwähnt unterscheiden sich die Attribute eins bis vier vom Zielattribut fünf.
Für nicht numerische Attribute gibt es die Operation:
CreatePredicatesIs[dataSet, row];
Der Input dieser Operation ist das Datenobjekt „IrisData“, jedoch befindet sich das
Zielattribut in der fünften Spalte. Mit der folgenden Befehlszeile wird das passende
Prädikat für das Zielattribut angelegt:
goalPreds=CreatePredicatesIs[IrisData,5];
Ebenfalls müssen für dieses Prädikat die richtigen Variablen angelegt werden, was die
Funktion „DefPredicateVars[];“ erledigt:
-54-
goalVars=DefPredicateVars[goalPreds];
Somit sind alle Vorbereitungen getroffen worden, um mit MLF aus den Daten einen
Entscheidungsbaum generieren kann. Wie schon in der Einleitung zu diesem Schritt
erläutert, bietet sich der FS-ID3-Algorithmus an, um einen Entscheidungsbaum zu
erstellen. Die Operation:
CreateID3[dataSet, predicateList, options];
übernimmt diese Aufgabe.
Optional kann für den Algorithmus die zu erstellende „Tiefe“ des Entscheidungsbaumes
angegeben werden.
Für das Beispiel genügen als Angabe die Namen der Variablen, der Prädikate sowie die
Bezeichnung des Datenobjektes:
IrisTree=CreateID3[IrisData,testVars,goalVars];
Mit dieser Befehlszeile generiert MLF aus dem Datenobjekt „IrisData“ unter der
Einbeziehung der Variablen der Prädikate für die Attribute eins bis vier sowie des
Zielattributes einen „fuzzyfizierten“ Entscheidungsbaum.
Optional kann der erstellte Entscheidungsbaum grafisch ausgegeben werden.
Wie schon in den vorigen Schritten wird dafür die Operation „Graphic[]“ für die
Generierung des passenden „Graphic“ Datenobjektes und die Operation „Show[]“ für die
Ausgabe des „Graphic“ Datenobjektes benutzt.
Der Unterschied zu den vorigen grafischen Ausgaben liegt darin, das es eine eigene
Funktion gibt, welche den Plott von einem Entscheidungsbaum erledigt, die mit der
Operation „CreateID3[]“ generiert wurde:
PlotID3[tree, options];
Die Funktion „Graphics[]“ verlangt als Input ein Datenobjekt, damit auch die
Beschriftungen der Blätter des Entscheidungsbaumes grafisch ausgegeben werden
können, muss zusätzlich noch das Datenobjekt mit den Beschriftungen der Blätter
angeben werden. Die Bezeichnung „Beschriftung der Blätter“ ist nicht ganz korrekt, denn
es wird die Legende passend zum Entscheidungsbaum ausgeben und nicht jedes einzelne
Blatt benannt. Die Operation:
PlotClassLegend[goalVars,options];
erstellt eine solche Legende.
Die Angabe des Ausdrucks
{PlotID3[IrisTree],PlotClassLegend[goalVars]}
anstatt der Angabe eines Datenobjektes für die Operation „Graphics[]“ erledigt dies.
Zusätzlich wird durch die Angabe der Optionen „AspectRatio ->…“ die Größe des
Plottes und der Option „Plotrange->…“ die Menge der anzuzeigenden
Merkmalsausprägungen beeinflußt. Gesamt sieht der Input der Funktion „Graphics[]“ wie
-55-
folgt aus:
Graphics[{PlotID3[IrisTree],PlotClassLegend[goalVars]}, AspectRatio > 0.4],PlotRange >
All
Darauf angewandt die Operation Show[];
Show [Graphics[{PlotID3[IrisTree],PlotClassLegend[goalVars]}, AspectRatio > 0.4],
PlotRange > All];
ergibt dann den grafischen Output, welcher den Entscheidungsbaum und die
dazugehörige Legende darstellt.
Der Entscheidungsbaum ist folgendermaßen zu interpretieren: wenn das Attribut
„petal_length“ der Pflanze „mehr“ als 150 mm beträgt, geht es weiter zum nächsten
Knoten (petal_width), sonst hat die Pflanze die Merkmalsausprägung „Iris-versicol“ beim
fünften Attribut. Beim nächsten Knoten stellt sich diese Frage für das Attribut
„pedal_width“, wenn der Wert der Pflanze größer als 100 mm ist, gehört die Pflanze der
Unterart „Iris-virginica“ an, sonst der Klasse „Iris-setosa“. Hier liegt auch die Stärke der
Fuzzy-Logik, denn beim zweiten Knoten („pedal_width“) kann immer noch durch eine
Zugehörigkeitsfunktion ein aussagekräftiger Wert für die Bestimmung der
Klassenzugehörigeit ermittelt werden.
-56-
6.2.7 Auswertung der Ergebnisse
Damit die Richtigkeit und vor allem die „Funktionalität“ des erstellten
Entscheidungsbaumes garantiert ist, sollte er auch getestet werden. Dafür sollte dem
Entscheidungsbaum eine Datenmenge gegeben und diese anhand des
Entscheidungsbaumes (neu) klassifiziert werden. Dafür bieten sich entweder die
originalen Daten, aus denen der Entscheidungsbaum gebaut wurde, oder andere
Datensätze, welche die gleichen Attribute enthalten, an. Es ist besser, andere Daten zu
verwenden, weil damit garantiert wird, daß es keinen Zusammenhang zwischen den
Daten und den Entscheidungsbaum geben kann. Für die Überprüfung der Funktionsweise
genügen die Originaldaten, wobei jedoch in der Praxis der Schritt zu anderen Daten für
einen Beweis der korrekten Arbeitsweise des erstellten „Entscheidungsbaumes“ besser
ist.
Um nachzuprüfen, wie „korrekt“ der Entscheidungsbaum klassifiziert ist, muss eine
Datenmenge von ihm bewertet werden. Das bedeutet, dass das Zielattribut der Daten für
jeden einzelnen Eintrag ersetzt werden muss durch die Ergebnisse des
Entscheidungsbaumes. Danach wird die so erstellte Datenmenge mit den dafür
zugrundeliegenden Daten verglichen. Dadurch wird ersichtlich, wie viele und vor allem
welche Einträge in den Daten falsch klassifiziert wurden.
Dafür muss zuerst ein neues Datenobjekt angelegt werden. Dieses Datenobjekt soll die
neu klassifizierten Daten beinhalten. In MLF gibt es die Operation:
RecallID3[dataSet, tree, options];
Da für das Beispiel keine Ersatzdatensätze existieren, müssen die originalen Daten
verwendet werden. Das Datenobjekt mit dem originalen Datensatz lautet „IrisData“ und
der FS-ID3 Baum wurde unter dem Namen „IrisTree“ angelegt. Mit dem Aufruf der
Funktion „RecallID3[]“ und dem Zuweisungsoperator „=“ werden alle Dateneinträge des
Datenobjekts bezüglich des Attributes fünf mit dem Entscheidungsbaumes „IrisTree“
neubewertet und als neues Datenobjekt angelegt:
recalledID3=RecallID3[IrisData,IrisTree];
Der Name des neuen Datenobjektes lautet „recalledID3“. Dieses Datenobjekt alleine ist
noch „wertlos“, denn es muss als nächstes mit den ihm zugrunde liegenden originalen
Datenobjekt verglichen werden.
Für solche Vergleiche von Datensätzen existiert die Operation:
CompEvalMatrix[originalClassification, newClassification];
Sie vergleicht die angegebenen Datenmenge und hebt ihre Unterschiede beziehungsweise
Gleichheiten hervor. Für die grafische Ausgabe wird ein Datenobjekt angelegt, welches
den Output der Operation „CompEvalMatrx[];“ beinhaltet. Mit der folgenden
Befehlszeile wird dieses Datenobjekt angelegt:
evalMatrix=CompEvalMatrix[GetData[IrisData,All,5],recalledID3]
-57-
Mittels der Operation „GetData[]“ werden die gewünschten Angaben an die Operation
„CompEvalMatrix[]“ geliefert.
Es gibt nun zwei Arten, wie die Bewertung ausgegeben werden kann, entweder in Form
von einer Matrix oder einer Grafik.
(Die Bewertung in Form einer Matrix ist sehr puristisch, dafür aber sehr aussagekräftig.)
Mit dem „Mapp-All“ Operator (//) wird auf jeden Ausdruck des Objektes, welches die
Bewertung enthält, die Funktion „Matrixform[]“ angewandt. Dadurch wird das
Datenobjekt in die richtige Form gebracht und grafisch ausgegeben:
evalMatrix//MatrixForm
Das „;“ am Ende des Ausdrucks muss weggelassen werden, denn der „//“ Operator
verlangt als Input nur zwei Argumente (einen Ausdruck und eine Operation) und somit
dieses Token3 automatisch impliziert. Die Ausgabe sieht wie folgt aus:
Für eine grafisch „angenehmere“ Ausgabe bietet sich die Operation:
PlotEvalChart3D[evaluationMatrix];
an. Diese Funktion gibt das Datenobjekt, also jenes, welches die Unterschiede zwischen
den Datensätzen beinhaltet, in einer dreidimensionalen Grafik aus. Durch „ApplyOperator“ (@) wird die Operation „PlotEvalChart3D“ auf das Datenobjekt „evalMatrix“
angewandt:
PlotEvalChart3D@evalMatrix;
Das Ergebnis sieht folgendermaßen aus:
3 Token = Zeichen einer attributiven Grammatiken von dem nicht weiter abgeleitet werden kann.
-58-
1Prediction
2
3
1
0.75
0.5
Percentage
0.25
0
1
2
Class
3
Durch die beiden Ausgaben (Matrix und Grafik) wird ersichtlich, dass ungefähr 88% der
ersten Merkmalsausprägung des Zielattributes (Iris-versicol) richtig erkannt wurden, 100
% der zweiten (Iris-setosa) und wiederum 88% der dritten (Iris-virginica). Das heißt, der
entwickelte Entscheidungsbaum liefert bereits sehr gute Ergebnisse.
Für tiefere Einsichten bietet es sich an, die falsch klassifizierten Einträge der
Datenobjekte ausgeben zu lassen. Dafür gibt es bereits eine Funktion in MLF, die dies
erledigt:
ExtractNonMatchingRecs[dataSet, classPos, evaluationMatrix];
Diese Operation liefert die Einträge, besser gesagt die Nummer derer, welche nicht
übereinstimmten, im Vergleich:
ExtractNonMatchingRecs[IrisData,5,recalledID3]
Als Angabe benötigt die Funktion die originale Datenmenge („IrisData“), das Zielattribut
(die Nummer fünf) nach dem klassifiziert wurde, und dass Datenobjekt, welches die
Bewertung beinhaltet („recalledID3“).
Danach müssen alle Einträge im originalen Datensatz, welche falsch bewertet wurden,
grafisch ausgeben werden. Die Nummern wurden bereits im letzten Verarbeitungsschritt
ermittelt. Jetzt folgt das Heraussuchen der dazupassenden Einträge im Datensatz. Mit der
Operation:
Extract[expr, list];
werden alle Einträge eines Ausdrucks oder Datenobjektes anhand einer Liste ausgeben.
Die Angabe des gesamten Datenobjektes „IrisData“ wäre falsch, da nicht das gesamte
Datenobjekt gebraucht wird, sondern nur bestimmte aus dessen Inhalt. Mit der Funktion
„GetData[]“:
GetData[IrisData]
-59-
wird der Inhalt vom Datenobjekt „IrisData“ ausgegeben.
Für die grafische Ausgabe muss das Datenobjekt „failedS“ noch in die richtige Form
gebracht werden. Durch den „//“ Operator wird diesesmal die Funktion „Tableform“ auf
das Datenobjekt „failedS“ angewandt. Diese Operation erledigt die grafische Ausgabe,
indem das ihm übergebene Datenobjekt in Form einer Tabelle gebracht und anschließend
auf den Bildschirm ausgegeben wird. Die gesamte Befehlszeile für die Ermittlung und
Ausgabe der im Beispiel falsch klassifizierten Einträge sieht folgendermaßen aus:
failedS=Extract[GetData[IrisData], ExtractNonMatchingRecs[IrisData,5,recalledID3]];
failedS // TableForm
Als Output wird eine Matrix mit den gewünschten Einträgen generiert:
5.9
6.7
6.
7.2
6.3
6.1
3.2
3.
2.2
3.
2.8
2.6
4.8
5.
5.
5.8
5.1
5.6
1.8
1.7
1.5
1.6
1.5
1.4
1.
1.
3.
3.
3.
3.
Anhand dieser Matrix ist es möglich, sich weitere Gedanken darüber zu machen, wie die
Klassifizierung verbessert werden kann, also wie die Fuzzy-Sets neu justiert werden
könnten. Im Beispiel wurde bereits eine Trefferquote von 100% für eine
Merkmalsausprägung und 88% für die restlichen beiden Ausprägungen des Zielattributes
erreicht, was eigentlich ein bereits sehr guter Wert ist.
Es wären noch weitere grafische Analysen der Regelbasis möglich, die aber nur eine
andere Darstellung der bereits erzielten Ergebnisse wären und somit nicht wesentlich
aussagekräftiger sind als die bisher gemachten grafischen Ausgaben.
6.2.8 Erzeugen und testen einer Regelbasis
Wie bereits in der Einführung zu „Supervised Learning“ erläutert ist es in MLF möglich,
eine Regelbasis zu erstellen. Für die Erstellung einer Regelbasis bieten sich einerseits der
FS-Miner, andererseits der FS-FOIL Algorithmus an, wobei die Grundidee für den FSFOIL von J. Quinlay und der des FS-Miner von der Firma SCCH stammte.
Der Unterschied zwischen den beiden Algorithmen FS-MINER und FS-FOIL liegt darin,
dass FS-FOILgeeignet ist, eine Regelbasis zu erstellen, welche alle
Merkmalsausprägungen des Zielattributes zum Zeitpunkt der Erstellung klassifizieren
-60-
kann. FS-Miner hingegen ist dazu bestimmt, eine Regelbasis für zukünftige weitere
Merkmalsausprägungen des Zielattributes zu erstellen, welche zum Zeitpunkt der
Erstellung der Regelbasis noch nicht bekannt waren. Folglich ist die Frage nach der
Verwendung der Algorithmen, ein Frage der Veränderbarkeit der Daten. Da die erstellten
Regelbasen nur für bereits bekannte Merkmalsausprägungen eine Datenmenge richtig
klassifizieren sollen, generiert der FS-Foil Algorithmus folglich auch sehr kompakte
Regelbasen. FS-Miner hingegen erstellt sehr umfangreiche Regelbasen, und dies bereits
für sehr „kleine“ Datensätze. Jedoch sind gerade in der Medizin aber Regelbasen
interessant, die auch mit „neuen“ Merkmalsausprägungen zurechtkommen. Als Beispiel
wäre eine Regelbasis für Hepatitis zu nennen, die auch mit neuen Unterarten der
Erkrankung zurechtkommen würde.
Für das Beispiel wird die Vorgehensweise für alle zwei Algorithmen erläutert.
Zuerst sei der FS-Foil dargestellt.
Fs-Foil
Zur Generierung einer Regelbasis mit diesem Algorithmus ist kein besonderer Aufwand
zu betreiben. Die Operation:
CreateFOIL[dataSet, predicateList, goalList, options];
benutzt die in MLF implementierte Form des FS-Foil und wendet sie an den angegebenen
Daten an. Als Input verlangt die Operation „CreateFOIL[]“ eine Menge an Daten, aus
denen der Algorithmus die auch anzugebenden Prädikate des Zielattributes und der
restlichen Attribute anwenden kann. Es können auch verschiedene optionale Angaben
getätigt werden, wie genau4 zum Beispiel die Regelbasis klassifiziert werden soll usw.
Für das Beispiel wurden bereits im letzten Schritt, also bei der Erstellung eines
Entscheidungsbaumes, die geeigneten Prädikate angelegt, diese können natürlich
weiterverwendet werden. Somit genügt die Angabe der nächsten Befehlszeile, damit
MLF eine Regelbasis mit dem FS-Foil Algorithmus erstellt:
FoilIrisRules=CreateFOIL[IrisData,testVars,goalVars,MinConf > 0.9];
Die Regelbasis wurde im Datenobjekt „FoilIrisRules“ gespeichert und kann jederzeit
wieder abgerufen werden. Mit der Operation:
PrintFOILRules [ruleSet, options];
können die erstellten Regeln grafisch ausgegeben werden. Die alleinige Angabe des
Datenobjektes, welches die Regeln beinhaltet, reicht dafür vollkommen aus, für das
Beispiel ergibt die folgende Befehlszeile:
PrintFOILRules[FoilIrisRules]
4 Alle Regeln welche mit ihrer Entscheidungsrate unter der angegebenen liegen, werden
nicht aufgenommen..
-61-
den folgenden Ouput:
class_Is_Iris- setosa
class_Is_Iris- versicol
class_Is_Iris- virginica
petal_width_Is_M
petal_width_Is_L
petal_length_Is_VL
petal_width_IsAtLeast_H
Dies ist zwar interessant, aber noch nicht aussagekräftig genug. Deswegen gibt es die
optionale Angabe „Info->True“ für diese Funktion. Damit werden statistische Angaben
für die gefundenen Regeln grafisch mit ausgegeben:
PrintFOILRules[FoilIrisRules, Info > True];
Der Output sieht wie folgt für das Beispiel aus:
35.8838
3.84797
11.6601
0.
45.8838
3.84797
class_Is_Iris- versicol 50.
0.
0.
50.
0.
0.
class_Is_Iris- virginica 46.152
2.4561
46.152
2.4561
14.1162
0.903151
38.3399
1.
4.11624
0.922626
1.
0.333333
1.
0.333333
3.84797
0.949471
3.84797
0.949471
0.239225 petal_width_Is_M
0.0777343 petal_width_Is_L
0.305892 Total
petal_length_Is_VL
Total
0.30768
0.30768
Total
Der grafische Output ist wie folgt zu verstehen:
Zu den Regeln passend stehen in den Spalten immer Angaben zu deren Statistiken
bezüglich ihrer Anwendung auf die Daten5.
In der ersten Spalte steht die „True true – Rate“ in Prozent, also wie viele Einträge des
Datensatzes durch diese Regel zu einer Klasse zugehörig eingestuft wurden und auch
korrekt waren. In der zweiten Spalte steht die „True false – Rate“; sie sagt aus, wie viele
Einträge des Datensatzes durch diese Regel zu einer Klasse als zugehörig eingestuft
wurden und dabei in Wirklichkeit falsch waren.
Die dritte Spalte gibt ebenfalls in Prozent an, wie viele Datensätze durch diese Regel
überhaupt nicht gedeckt wurden.
Die vierte Spalte drückt das „Vertrauen“ in diese Regel aus, sprich wie hoch der
gesammte Prozentsatz der richtig klassifizierten Beispiele war.
Die fünfte Spalte steht für die „Verwendungshäufigkeit“ bezüglich der anderen Regeln.
Mit dieser Ausgabe wird die Durchsicht der erstellten Regelbasis beziehungsweise
einzelner Regeln erheblich vereinfacht, da über den Angaben in der grafischen Ausgabe
gezielt nach den „Schwachstellen“ der Regelbasis gesucht werden kann.
Zur „Kontrolle“ der Regelbasis, also der Probe der Regelbasis, muss wieder ein
geeigneter Datensatz mit der Regelbasis neu bewertet werden.
Dies ist die gleiche Vorgangsweise wie bei der Erstellung eines Entscheidungsbaumes.
5 Gemeint sind die Daten, mit denen die Regelbasis erstellt wurde.
-62-
Zuerst müssen die Daten neu bewertet werden, dann können diese mit den alten
verglichen und zum Schluss die Ergebnisse interpretiert werden.
Wie für den FS-ID3 Algorithmus existiert auch für die Regelbasen, welche mit dem FSFoil Algorithmus erstellt wurden, eine Operation, welche den angegebenen Datensatz neu
bewertet und in einem neuen Datenobjekt anlegt:
RecallFOIL [dataSet, foilRules, options];
Als Input genügt dieser Operation ein Datenobjekt mit dem geeigneten Datensatz und die
entsprechende Regelbasis:
recalledFOIL=RecallFOIL[IrisData,FoilIrisRules];
Die angegebene Befehlszeile legt das Datenobjekt „recalledFOIL“ für das Beispiel an.
Als Nächstes muss die Auswertung erfolgen, das heißt die Originaldaten werden mit den
neubewerteten Daten verglichen und die Ergebnisse wiederum in einer Matrix
gespeichert.
Die Operation „CompEvalMatrix[]“ mit der Angabe:
GetData[IrisData,All,5]
der optionalen Variablen „ALL“ (Ausgabe aller Attribute), dem Zielattribut (fünf) und
der Angabe des Datenobjektes mit den neubewerteten Daten („recalledFOIL“) löst dieses
Problem:
evalMatrix=CompEvalMatrix[GetData[IrisData,All,5],recalledFOIL];
Durch die Anwendung des „MatrixForm“ Operators durch den „//“ Operator auf die
erstellte Ergebnis Matrix:
wird der folgende Output erzeugt:
Für eine Ausgabe in Grafikform genügt die Anwendung der
PlotEvalChart3D[evaluationMatrix];
Funktion, um die Ergebnis-matrix grafisch plotten zu lassen:
-63-
Für das Beispiel wird von Mathematika folgender Ouput erstellt und grafisch geplottet:
1Prediction
2
3
1
0.75
0.5
Percentage
0.25
0
1
2
3
Class
Um eine bessere Ansicht über die „Schwächen“ der Regelbasis zu erhalten, bietet es sich
an, eine Liste zu erstellen, welche alle Datensätze, die bei der Neuklassifizierung mit der
Regelbasis falsch eingeteilten wurden, enthält.
Dazu ist es notwendig, die originalen Daten mit den neubewerteten zu vergleichen. Dafür
bietet sich die folgende Operation an:
ExtractNonMatchingRecs[dataSet, classPos, evaluationMatrix];
Als Input verlangt diese Funktion die originalen Daten sowie das Attribut, nach welchem
die unterschiedlichen Einträge herausgesucht werden sollen sowie den neubewerteten
Datensatz.
Für das Beispiel genügt die folgende Befehlszeile, um diese Aufgabe Mathematica
erledigen zu lassen:
ExtractNonMatchingRecs[IrisData,5,recalledFOIL]
Das ursprüngliche Datenobjekt wurde unter dem Namen „IrisData“ angelegt, das fünfte
Attribut (Zielattribut) wurde neubewertet und der neuklassifizierte Datensatz unter dem
Namen „recalledFOIL“ als Datenobjekt angelegt.
Dies ist für die Ausgabe von nicht klassifizierten Einträgen zu wenig. Damit diese
ausgewählten Einträge auch grafisch ausgegeben werden können, muss ein Datenobjekt
mit den falsch klassifizierten Datensätzen angelegt werden. Mittels des „GetDate[]“
Operators werden alle Einträge des originalen Datensatzes ausgegeben. Alle Einträge der
originalen Daten und die Auswahl aller falsch klassifizierten Einträge des neuen
Datensatzes dienen als Input für die Operation:
Extract[expr, list];
-64-
wobei dem Output dieser Operation mittels des „Zuweisungsoperators“ (=) ein Namen
zugewiesen wird.
Für das Beispiel drückt die folgende Befehlszeile dies aus:
failedS=Extract[GetData@irisData, ExtractNonMatchingRecs[IrisData,5,recalledFOIL]];
Damit das Datenobjekt in die richtige Form gebracht wird, ist es am effektivsten, den „//“
Operator gepaart mit dem Befehl „Tabelform“ auf das neu angelegte Datenobjekt
anzuwenden:
failedS//TableForm
Als Ergebnis generiert MLF eine Tabelle, welche alle falsch neuklassifizierten Einträge
der ursprünglichen Datenmenge beinhaltet. Anhand dieser Daten ist es sinnvoll, die
Fuzzy-Sets, welche der Regelbasis zugrundeliegen, neu zu definieren beziehungsweise zu
optimieren. Für das Beispiel ergibt sich der folgende Output:
5.9
6.7
6.
7.2
6.3
6.1
3.2
3.
2.2
3.
2.8
2.6
4.8
5.
5.
5.8
5.1
5.6
1.8
1.7
1.5
1.6
1.5
1.4
1.
1.
3.
3.
3.
3.
FS-Miner
Ebenso wie für den FS-FOIL-Algorithmus existiert für den FS-Miner-Algorithmus eine
Funktion, welche diesen auf einen Datensatz anwendet:
CreateMINER[dataSet,predicateList,goalList,options];
Als Input verlangt die Operation einen Datensatz, eine Menge an Prädikaten, (welche die
Fuzzyfizierung darstellen) Zielattribute sowie optionale Angaben für die Suche nach
Regeln.
z.B.: Wie hoch die „True-Positive Rate“ der Regeln für die Aufnahme in die Regelbasis
sein soll.
Der Datensatz wurde bereits am Anfang im Datenobjekt „IrisData“ gespeichert, die
Fuzzy-Prädikate wurden im Datenobjekt „testVars“ angelegt, ebenso wie die
Zielvariablen. Für das Beispiel macht als optionale Angabe ein Wert zwischen 80% und
90% für die „True-Positive Rate“ Sinn.
Somit sollte sichergestellt sein, dass keine „aussagenschwache“ Regeln in die Regelbasis
aufgenommen werden. Für das Beispiel sieht der Ausdruck für die Erstellung der
Regelbasis mit dem FS-Miner Algorithmus wie folgt aus:
CreateMINER[IrisData,testVars,goalVars,MinConf > 0.9];
-65-
Mit dem Zuweisungsoperator „=“ wird das Ergebnis dieses Ausdrucks wieder einem
Namen zugewiesen:
MinerIrisRules=CreateMINER[IrisData,testVars,goalVars,MinConf > 0.9];
Die Ausgabe der gefunden Regeln übernimmt, wie bei dem FS-ID3-Algorithmus und
dem FS-FOIL-Algorithmus, wieder eine eigene Operation:
PrintMINERRules[ruleSet,options];
Diese Operation gibt einzig die gefundenen Regeln aus, dafür benötigt sie als Input das
Datenobjekt mit der Regelbasis und optionale Angaben über die Menge der
ausgegebenen Regeln. Mit der Angabe „Info -> True“ gibt diese Operation wieder
verschiedene statistische Informationen von den gefundenen Regeln aus (siehe
PrintFOILRules[]):
PrintMINERRules[MinerIrisRules,Info > True]
Der Output nach der Auswertung der obigen Funktion für das Beispiel sieht wie folgt
aus:
class_Is_Iris- versicol
47.5439
36.0829
35.8838
11.4482
37.7614
47.5439
2.
3.31928
2.
0.
0.
3.31928
50.
0.
0.
50.
0.
0.
class_Is_Iris- virginica 29.7032
0.
45.152
2.30407
27.8552
0.
24.1357
0.
47.
2.30407
2.4561
13.9171
14.1162
38.5518
12.2386
2.4561
0.959632
0.915759
0.947207
1.
1.
0.934741
1.
0.333333
1.
0.333333
20.2968
1.
4.84797
0.951448
22.1448
1.
25.8643
1.
3.
0.953268
0.316959
0.240553
0.239225
0.0763215
0.251743
0.316959
0.198021
0.301014
0.185701
0.160904
0.313333
petal_width_IsAtLeast_L
sepal_width_IsAtMost_L
petal_width_Is_M
petal_width_Is_M
Total
petal_width_Is_VL
Total
petal_width_IsAtLeast_M
petal_width_IsAtLeast_M
petal_length_IsAtLeast_H
Total
petal_length_IsAtMost_H
petal_width_IsAtMost_M
petal_length_IsAtMost_M
sepal_width_IsAtLeast_M
petal_length_Is_VH
petal_length_Is_VH
petal_width_Is_VH
Die Bedeutung der Spalten ist diesselbe wie für die Operation „PrintFOILRules[]“ (siehe
Punkt „FS-FOIL“).
Für die weitere Durchsicht und Bearbeitung der Regelbasis sollte wiederum ein
Datenobjekt mit einem neubewerteten Datensatz angelegt werden. Für diese Aufgabe
wurde in MLF die Operation:
RecallMINER[dataSet,minerRules,options];
implementiert. Als Input verlangt diese Operation einen Datensatz, von welchem die
Einträge bezüglich des Zielattributes neu bewertet werden können, sowie ein Datenobjekt
mit der von „FS-Miner“ generierten Regelbasis.
recalledMINER=RecallMINER[IrisData,MinerIrisRules]; Das geeignete Datenobjekt mit dem Datensatz ist wiederum „IrisData“ und die
Regelbasis vom „FS-Miner“-Algorithmus wurde unter dem Namen „MinerIrisRules“
angelegt.
-66-
Für die Bewertung der Regelbasis sollte wiederum eine „Bewertungs-Matrix“ erstellt
werden. Ebenso wie für die Algorithmen FS-FOIL und FS-ID3 wird dafür die Operation
„ComEvalMatrix[];“ benutzt. Als Input verlangt diese Operation sowohl den neu
bewerteten als auch den ursprünglichen Datensatz. Mit dem Zuweisungsoperator „=“
wird dem so erstellten Datensatz wieder ein Name zu gewiesen. Für das Beispiel ist die
folgende Befehlszeile ausreichend:
evalMatrix=CompEvalMatrix[GetData[IrisData,All,5],recalledMINER];
Für den Output der alleinigen Daten der “Bewertungs-Matrix” wird wiederum der “//”
Operator gepaart mit dem Befehl “MatrixForm” verwendet:
Der Output, welcher für das Beispiel generiert wird, sieht folgendermaßen aus:
Für die Ausgabe einer Grafik des Datenobjektes „evalMatrix“ genügt die Anwendung der
Operation „PlotEvalChart3D[]“ mittels dem Apply-operators (@) auf das passende
Datenobjekt:
Als Output wird die folgende Grafik generiert:
1Prediction
2
3
1
0.75
0.5
Percentage
0.25
0
1
2
3
Class
-67-
Es empfiehlt sich weiters, die falsch klassifizierten Einträge der originalen Daten plotten
zu lassen. Dafür müssen zuerst alle voneinander unterschiedlichen Einträge der
originalen und neubewerteten Daten herausgefunden werden. Dafür existiert, wie bereits
für den Algorithmus FS-FOIL erläutert, die Funktion „ExtractNonMatchingRecs[]“.
Ihr Input besteht aus der Angabe des originalen sowie des neubewerteten Datenobjektes
(IrisData) und des Zielattributes (fünf):
ExtractNonMatchingRecs[IrisData,5,recalledMINER]
Danach können die somit als „falsch“ klassifizierten Dateneinträge des neubewerteten
Datensatzes aus dem originalen Datenobjekt herausgesucht und in einem neuen
Datenobjekt gespeichert werden.
Die Operation:
Extract[expr, list]:
erledigt dies unter der Angabe aller Einträge der originalen Daten und der Angabe der
„falsch“ klassifizierten des neubewerteten Datensatzes.
Gesamt sieht die Befehlszeile für das Beispiel wie folgt aus:
failedS=Extract[GetData@IrisData, ExtractNonMatchingRecs[IrisData,5,recalledMINER]];
Damit das Datenobjekt “failedS” in tabellarischer Form ausgegeben werden kann, genügt
wiederum der „//” Operator verbunden mit der Angabe des Befehls „Tableform“
failedS//TableForm
Für das Beispiel wird der folgende Output generiert:
5.9
6.7
4.9
6.
6.3
6.1
3.2
3.
2.5
2.2
2.8
2.6
4.8
5.
4.5
5.
5.1
5.6
1.8
1.7
1.7
1.5
1.5
1.4
1.
1.
3.
3.
3.
3.
Der Output enthält die falsch klassifizierten Einträge mit allen Attributen und deren
Merkmalsausprägungen. Somit sollte es für den Benutzer wiederum möglich sein, die der
Regelbasis zugrundeliegenden Fuzzy-Sets so zu verändern, dass auch diese Einträge
korrekt klassifiziert werden.
-68-
Optimieren von Regelbasen (FS-RENO)
Für die Optimierung der im letzten Arbeitsschritt erstellten Regelbasen des letzten
Arbeitsschrittes wurde der FS-RENO-Algorithmus in MLF implementiert. Dieser
Algorithmus optimiert mittels Approximation die ihm übergebende Regelbasis. Der Input
des FS-RENO-Algorithmus ist auf sechs Dimensionen beschränkt (sechs
Eingangsattribute), wobei schon bei weniger als sechs Dimensionen ein riesiger
Rechenaufwand betrieben werden muss;
deswegen auch diese Beschränkung.
Um eine gegebene Regelbasis optimieren zu lassen, müssen ihre Regeln einzeln in einer
Liste gespeichert und in einem Datenobjekt verpackt werden. Der Grund dafür liegt
darin, dass der FS-RENO-Algorithmus jede Regel für dessen Optimierung einzeln
aufrufen muss. Für das Herauslesen der einzelnen Regeln muss kein Script in
Mathematica geschrieben werden, dafür existiert bereits von Mathematica selbst eine
Operation, welche aus einem gegebenen File alle einzelnen Einträge extrahiert:
Flatten[list];
Zur Auswahl stehen einerseits die Regelbasis vom FS-MINER-Algorithmus
(IrisFoilRules), andererseits die Regelbasis des Algorithmus FS-FOIL (IrisMinerRules).
Die oben erwähnte Operation, angewandt auf eine der zuvor generierten Regelbasen,
erzeugt ein Datenobjekt mit den extrahierten Regeln, welchem wiederum ein Name
zugewiesen werden sollte.
Für das Beispiel genügt die folgende Befehlszeile:
FlattedIrisFoilRules = Flatten [IrisFoilRules];
Für die Anwendung des FS-RENO-Algorithmus existiert die Operation:
OptimizeRENO[dataSet, controller, options];
Als Input verlangt diese Operation ein Datenobjekt, welches Daten beinhaltet, an denen
der FS-RENO-Algorithmus die Regeln „trainieren“ kann. Für das Beispiel wäre dies das
Datenobjekt „IrisData“. Als zweiten Input verlangt diese Operation eine Regelbasis,
entweder erstellt vom FS-Miner oder FS-FOIL Algorithmus. Es wäre auch möglich,
selbst eine Regelbasis zu erstellen und diese anzugeben.
Bei dem Beispiel ist es egal, welche Regelbasis genommen wird, deswegen wird die
erstellte Regelbasis vom FS-FOIL-Algorithmus benutzt, der im im Schritt 8. erzeugt
wurde.
Durch die Befehlszeile:
PrintRules[FlattedIrisFoilRules]
mit der Operation „PrintRules[]“ wird der Inhalt des Datenobjektes
„FlattedIrisFoilRules“ grafisch ausgegeben. Dieser Schritt ist optional und dient
hauptsächlich dazu, die Regeln der ursprünglichen Regelbasis mit der optimierten zu
-69-
vergleichen. Der Output von Mathematica für die Regelbasis des FS-FOIL-Algorithmus
hat das folgende Aussehen:
class_Is_Iris-setosa
petal_witdth_Is_M || petal_width_Is_L
class_Is_Iris-versicol
petal_length_Is_VL
class_Is_Iris-virginica
Durch die Angabe der folgenden Befehlszeile wird die Regelbasis mit der Operation
„OptimizeRENO[]“ optimiert:
optimizedFoilRules = OptimizeReno[FlattedIrisFoilRules];
Um die Veränderung an der Regelbasis ersichtlich zu machen beziehungsweise die
optimierte Regelbasis grafisch ausgeben zu lassen, bietet sich die Operation „PrintRules
[]“ an. Ihr genügt als Input die optimierte Regelbasis (optimizedFoilRules):
PrintRules[optimizedFoilRules]
Als Output generiert Mathematica respektive MLF eine Grafik, welche die optimierten
Regeln beinhaltet:
OptimizeReno[{class_Is_Iris-setosa, {}, petal_width_Is_M || petal_width_Is_L,
class_Is_Iris-versicol, {},petal_length_Is_VL, class_Is_Iris-virginica, {},
petal_width_IsAtLeast_H}]
6.3 Fazit
„Supervised Learning“ ist geeignet, aus einer Menge von Daten neues Wissen in Form
von Regelbasen oder Entscheidungsbäumen zu generieren. Diese Aufgabe beherrscht
MLF hervorragend. Die generierten Entscheidungsbäume sind „anwendungsfähig“, die
Regelbasen sind „aussagekräftig“. Selbst der Rechenaufwand und das
Antwortzeitverhalten des Templates MLF befinden sich in einem moderaten Bereich. Der
einzige Wermutstropfen liegt darin, dass die Daten bereits in aufgearbeiteter Form dem
-70-
„Supervised Learning“ von MLF übergeben werden müssen. Die Daten roh, ohne voriger
Durchsicht mit den Operationen, Funktionen beziehungsweise Algorithmen vom
„Supervised Learning“ zu bearbeiten, wäre sinnlos. Die Daten in Mathematica in MLF zu
bearbeiten ist nur bis zu einem bestimmten Grad machbar, und geht vom Anlegen von
neuen Datenobjekten bis zum Herauslesen von Spalten oder dergleichen aus bestehenden
Datenobjekten nicht darüber hinaus.
Der Mächtigkeit von „Supervised Learning“ tut dies zwar keinen Abbruch, da sowieso
(allgemein gesehen) im „Data Mining“ einen Schritt zuvor die Daten „durchgesichtet“
wurden. Somit sollten die Daten eigentlich schon in „bearbeiteter“ Form vorliegen.
Weiters ist noch festzuhalten, dass die Qualität der Daten für das „Supervised Learning“
wichtiger ist als die Quantität, somit stößt diese Verarbeitungsmethode von MLF bei
medizinischen Daten schnell an ihre Grenzen.
Alle Datensätze, die für diese Bakkalaureatsarbeit zur Verfügung gestellt wurden, waren
von schlechter Qualität. Entweder fehlte eine Dokumentation oder ein und dasselbe
Attribut wurde verschieden bezeichnet, daß heißt der Aufbereitung der Daten fließt
dadurch ein noch höherer Stellenwert zu. Deswegen gibt es auch die methodische
Zusammenfassung der Vorgehensweise des „Unsupervised Learnings“, welche im
nächsten Abschnitt erklärt werden wird.
Abschließend lässt sich festhalten, dass „Supervised Learning“ vom Tool MLF,
entwickelt von der in Hagenberg ansäßigen Firma „SCCH“ Möglichkeiten bietet, aus
dem in bestehenden medizinischen Datenbanken enthaltenen Daten neues Wissen durch
die Anwendung von fuzzyfizierten Algorithmen zu generieren.
-71-
7 Unsupervised Learning mit MLF
Beim „Unsupervised Learning“ handelt es sich um ein Analyseverfahren, bei dem das
Ziel nicht vorgegeben ist. Zum Vergleich dazu muss beim „Supervised Learning“ ein
Ziel vorgegeben sein. „Unsupervised Learning“ beschäftigt sich mit dem Clustern von
Daten und dem Finden von Zusammenhängen.
Aus diesem Grund wird das „Unsupervised Learning“ auch oft vor dem „Supervised
Learning“ durchgeführt, um einerseits herauszufinden, bei welchen Daten eine genauere
Analyse interessant sein könnte, und andererseits störende Daten zu beseitigen
(Verringerung der Datenmenge).
Das Prinzip von „Unsupervised Learning“ liegt darin, das nicht etwa auf Grund der
Ausgaben ein Gewicht (gemeint sind die Zusammenhänge) verändert wird, sondern nur
alle Gewichte gleichzeitig. Wenn nun der neue Output besser ist als der alte, werden
diese Gewichte weiter verwendet, andernfalls verworfen. Aus diesem Grund ist es auch
nicht notwendig, ein Ziel vorzugeben, da “Unsupervised Learning” ohne eine Anweisung
auskommt (Vergleich zur dynamischen Programmierung). Ein Nachteil ist sicherlich, daß
diese Lernart vor allem durch die vielen Vergleichsoperationen aufwendiger und damit in
der Verarbeitung langsamer ist als „Supervised Learning“.
MLF beherrscht drei verschiedene Verfahren zur Durchführung von „Unsupervised
Learning“:
•
•
•
SOM (Kohonen maps)
Fuzzy K-Means (clustering)
WARD (crisp clustering)
Es folgt nun eine kurze und überblicksmäßig gehaltene Einführung in die Theorie des
„Unsupervised Learnings“, danach werden die oben angeführten Algorithmen näher
behandelt.
7.1 Einführung zur Cluster-Analyse
Grundsätzlich geht es bei der Clutser-Analyse um die Gruppierung von Objekten einer
Menge, sodass Cluster entstehen, in denen die Ähnlichkeiten zwischen den Objekten
maximal und die Ähnlichkeiten zwischen den Clustern minimal werden.
-72-
7.1.1 Ähnlichkeits- und Distanzmaße
Intervallsskalierte Merkmale:
Euklidisches Distanzmaß
p
1/2
d ii ' =[ ∑  X ij − X i ' j 2 ]
j
p
Xij
Xi'j
Anzahl der Merkmale
Ausprägung des Objekts i auf dem Merkmal j
Ausprägung des Objektes i' auf dem Merkmal j
Üblicherweise werden die einzelnen Merkmale über die Objekte z-transformiert. Dabei
ist die Wahl der City-Block Metrik (Taxifahrer-Metrik) oft sehr sinnvoll, da in den Daten
häufig „Ausreißerwerte“ (überhöhte Merkmalsdifferenzen) zu finden sind und diese
somit vernachlässigt werden können.
p
1
d ii ' =[ ∑  X ij − X i ' j 1 ]
j
p
Xij
Xi'j
Anzahl der Merkmale
Ausprägung des Objekts i auf dem Merkmal j
Ausprägung des Objektes i' auf dem Merkmal j
Manchmal besteht das Problem, dass die Merkmale der Daten inkorrelieren und somit
das Distanzmaß ungleich beeinflusst wird. Dagegen gibt es jedoch Maßnahmen, die
gegebenenfalls getroffen werden können:
Faktoranalyse
Die Merkmale werden mittels Hauptkomponentenanalyse und Varimaxrotation
faktorenanalysiert. Das Distanzmaß wird dann aufgrund der Faktorenwerte der
interpretierbaren Faktoren berechnet. Inhaltlich und statistisch unbedeutende Faktoren
werden dabei nicht berücksichtigt. Voraussetzung für diese Analyse ist jedoch, dass die
aufgrund der Stichprobe ermittelte Faktorenstruktur auch für die durch die Clusteranalyse
gebildeten Untergruppen gilt.
•
-73-
Resudzakusuerte Variablen
Die gemeinsame Varianz zwischen den Variablen werden „herauspartialisiert“. Jene
Variable, die inhaltlich am Wichtigsten erscheint, geht standardisiert in die Distanzformel
ein. Diese Variable wird aus der zweiten herauspartialisiert. In der Distanzformel werden
dann, statt der ursprünglichen Werte, die standardisierten verwendet. Aus der dritten
Variable werden die Variablen Eins und Zwei herauspartialisiert usw. Hierbei ist es
Voraussetzung, dass auch die weiteren Variablen mehr als nur die Fehlervarianzanteile
beinhalten.
•
Mahalanobis - Distanz
Dieses Distanzmaß entspricht der euklidischen Distanz. Es berechnet über die
Faktorwerte aller Faktoren eine Hauptkomponentenanalyse.
•
7.1.2 Clusteranalytische Verfahren
Hierarchische Verfahren
Bei den hierarchischen Verfahren werden zuerst die paarweisen Distanzen zwischen allen
Objekten berechnet. Danach fusioniert man jene zwei Objekte zu einem Cluster, welche
die kleinste Distanz (entspricht der größten Ähnlichkeit) haben. Dadurch reduziert sich
die Anzahl der möglichen Cluster um eins. Nun werden die Clusterdistanzen der
verbleibenden Cluster erneuet verglichen und wieder jene zwei, die die kleinste Distanz
haben, zusammengefasst. Eine Darstellung dieses Prozesses kann in einem sogenannten
Dendrogramm6 erfolgen, auf das hier nicht näher eingegangen werden sollte. Nachteil
dieses Verfahrens ist, dass nach der Zuordnung eines Objektes zu einem Cluster diese
nicht mehr revidierbar ist. Nach eingehenden Analysen und Testläufen hat sich
herausgestellt, dass mit der sogenannten WARD-Methode für Ähnlichkeitsmaße die
besten Resultate erzielt werden.
Nicht-hierarchische Verfahren
Dabei gibt man die Anzahl der Cluster vor und versucht, die Startgruppierung durch
schrittweises Verschieben der einzelnen Objekte von einem zum anderen Cluster zu
verbessern. Allerdings ist dieses Verfahren bereits bei einer relativ geringen Anzahl von
Objekten sehr rechenaufwendig.
6 Dendrogramm ist ein Baum, der die hierarchische Zerlegung der Datenmenge in immer kleinere
Teilmengen darstellt.
-74-
Kombiniertes Verfahren
Hierbei werden das hierarchische und das nicht-hierarchische Verfahren kombiniert. Man
bestimmt zuerst mittels einer hierarchischen Clusteranalyse die Anzahl der Cluster und
verfeinert diese anschließend mit einem nicht-hirachischen Verfahren.
WARD-Verfahren
Beim WARD-Verfahren werden jene Cluster zusammengelegt, durch deren Fusion die
geringste Erhöhung der gesamten Fehlerquadratsumme ausgelöst wird. Am Anfang der
Fusionierung werden bevorzugt kleinere Cluster in Regionen mit hoher Objektdichte
gebildet. Daraus resultieren annähernd gleich groß gefüllte Cluster.
k-means Verfahren
Es wird eine fixe Anzahl (k) von Clustern vorgegeben. Danach werden die euklidischen
Distanzen zu allen Clusterschwerpunkten gemessen und gegebenfalls die Objekte
entsprechend dazu verschoben. Anschließend werden die Clusterschwerpunkte erneut
berechnet und die Objekt wieder neu angeordnet.
Die Zuordnung eines Objektes zu einem Cluster kann prinzipiell beliebig oft wiederholt
werden. Es wird jedoch grundsätzlich empfohlen, verschiedene Reihenfolgen für die
Objekte zu verwenden. Die Lösung ist jene, die durch verschiedene Startpositionen am
häufigsten bestätigt wurde.
Evaluierung der Cluster-Lösung
Man unterteilt eine Objektmenge zufällig in zwei gleich große Teilmengen A und B.
Danach wird je eine Clusteranalyse auf den Teilmengen durchgeführt, als Ergebnis
sollten dann beide Clusteranalysen übereinstimmen. Man kann das
Übereinstimmungsmaß Kappa durch den Anteil der Übereinstimmungen aller Objekte in
der Diagonalen folgendermaßen berechnen:
k
∑
P 0 −P e
K=
P= i
n
1−P e 0
k
f ii
P e=
∑ fi× f i
i
n2
Aus der Formel ergibt sich das Problem, dass die Art der Clusterbildung manchmal von
einem einzigen Objekt abhängig ist.
-75-
Es folgt eine Darstellungsweise der Methodik des „Unsupervised Learnings“ von MLF,
welches an einem leicht verständlichen Beispiel beschrieben wird.
7.2 SOM (Kohonen maps)
SOM (“Self Organized Maps”) wurden 1982 von Teuvo Kohonen entdeckt. Die
grundlegende Idee der SOM ist es, in die konkurrierende Lernregel ein Maß an
Sensibilität einzubringen, welche die Nachbarschaft beachtet. Damit können vollständig
ungelernte Neuronen vermieden und bestimmte topologische Eigenschaften gesteigert
werden, die in den abzubildenden Eigenschaften bewahrt werden sollten.
Nehmen wir an, ein Eingabemuster hat N Eigenschaften und es wird durch den Vektor x
in einem N-dimensionalen Musterraum dargestellt. Dann sollte ein „Netzwerk“ dieses
Eingabemuster auf einen Ausgaberaum abbilden. Der Ausgaberaum sollte ein ein- oder
zwei-dimensionales Feld von Ausgabeknoten sein, welche eine bestimmte topologische
Ordnung aufweisen. Die Frage ist, wie ein Netzwerk so trainiert werden kann, dass die
ordnenden Beziehungen beinhalten werden können. Kohonen schlug vor, dass
Ausgabeknoten lateral interagieren können, was zu den “Self Organized Maps” (SOM)
führt.
SOM sind folglich nichts anderes als selbstorganisierende Abbildungen von Rn auf eine
regelmäßige zwei-dimensionale Gitterstruktur.
7.2.1 Grundsätzlich Arbeitsweise einer SOM
1. Präsentation der Eingabedaten.
Zufällige Auswahl eines Datensatzes, wobei jedoch zu beachten ist, dass jeder
Datensatz gleich oft an die Reihe kommen sollte.
2. Ermitteln des Bestmatch.
Es wird der Datensatz ausgewählt, der am besten zu dem im vorherigen Punkt
ermittelten Datensatz passt (Bestmatching).
3. Lernen in der Nachbarschaft des Bestmatch.
Der ausgewählte Datensatz wird dem optimalen Datensatz um einen bestimmten Wert
angepasst (zum Beispiel Annäherung um 10%). Es werden auch alle Datensätze, die in
einem bestimmten Radius um den ausgewählten Datensatz liegen, ebenso modifiziert.
4. Ändern des Nachbarschaftsradius und Wiederholung.
Der Nachbarschaftsradius und die Anpassungsrate werden verkleinert und die Punkte
eins bis vier werden solange wiederholt, bis ein sinnvolles Ergebnis vorhanden ist.
-76-
Wie bereits erwähnt, werden Beispieldaten aus dem MLF-Tutorial mit „Unsupervised
Learning“ bearbeitet. Dies soll demonstrieren, wie SOM mittels MLF unter Mathematica
funktionieren.
7.2.2 Beispiel für SOM mit Mathematica & MLF
Zuerst muss einerseits die Grafikbibliothek, und andererseits das MLF AddOn in
Mathematica initialisiert werden. Das geschieht mit der folgenden Befehlssequenz:
Needs["Graphics`Graphics`"]
Needs["MLF`"]
Nach einer Shift-Enter Kombination, sollten beide für das Arbeiten in den MathematicaKernel eingebunden sein. Für die Darstellung der Funktionsweise von SOM's sollten
zufällig generierte Daten ausreichen. Ein von einem Zufallsgenerator erzeugtes Datenfeld
wird in der weiteren Folge durch „Unsupervised Learning“ weiterbearbeitet:
samples = 1000;
dims = 2;
data1 = Table[{Random[]*0.25, Random[]*0.25, 1}, {i, samples*0.25}];
data2 = Table[{0.25 + Random[]*0.4, 0.5 + Random[]*0.5, 2}, {i, samples}];
data3 = Table[{0.75 + Random[]*0.25, Random[], 3}, {i, samples}];
sampleData = DataSet[Join[data1, data2, data3], {"x", "y", "class"}];
Um einen Blick auf das Datenfeld werfen zu können, sollte der nachfolgende Plot-Befehl
genutzt werden:
Show@Graphics[Join[
PlotAttributes[sampleData, Dims > {1, 2}, Goal > 3, PointSize > 0.01]
], Axes > True, PlotRange > {{0, 1}, {0, 1}}, AspectRatio > 1];
Als Ergebnis erscheint eine Grafik auf dem Bildschirm, die in etwa das folgende
Aussehen haben:
-77-
Da nun ein geeigneter Datensatz vorhanden ist und dieser auch schon betrachtet wurde,
kann darauf basierend eine “Self organized map” (SOM) erstellt werden. Dies geschieht
mittels der CreateSOM[] Funktion.
Der CreateSOM[] Befehl sieht folgendermaßen aus:
CreateSOM[<daten>, <optionen>]
• <daten>
•
<optionen>
•
•
•
•
•
Größe der SOM – Matrix:
Maximales Fehlerlevel:
Typ:
Gewichtung der Attribute:
Initialisierung des Zählers:
Size->{x,y}
Errorlevel -> Automatic oder Angabe einer Zahl
Wahlweise “BATCH” oder “ONLINE”
Weights->Automatic oder Weights->{x,y,...}
Count-> Automatic oder Angabe einer Zahl
Bei dem Beispiel empfiehlt es sich, eine 5x5 Matrix mit der Gewichtung auf die Attribute
eins und zwei erstellen zu lassen. Es empfiehlt sich deswegen eine 5x5 Matrix, weil eine
größere Matrix zu rechenintensiv wäre und eine kleinere nicht anschaulich genug für eine
Einführung in SOM's wäre.
som = CreateSOM[
sampleData,
Weights > {1, 1, 0},
Size > {5, 5},
Errorlevel > Automatic,
Type > "BATCH"
];
-78-
Als Ergebnis erhält der Benutzer ein SOM Netzwerk mit 25 Knoten, welches mit dem
sogenannten BATCH-Algorithmus trainiert wurde.
Mit der „getData[]“ Operation können die berechneten SOM Vektoren grafisch
ausgegeben werden . Der Output sollte in etwa folgendermaßen aussehen:
In[14] := GetData[som]
Out[14]:= {{0.879765, 0.178109, 3.}, {0.893409, 0.309843, 3.}, {0.870901, 0.488904,
3.}, {0.879876, 0.696028, 3.}, {0.880435, 0.778117, 3.}, {0.876535,
0.147764, 3.}, {0.866258, 0.212901, 3.}, {0.783786, 0.477735,
2.72558}, {0.781696, 0.566048, 2.71146}, {0.820239, 0.777347,
2.80505}, {0.521673, 0.120482, 2.0813}, {0.579746, 0.51168,
2.25559}, {0.587787, 0.572178, 2.25575}, {0.622112, 0.71715,
2.19577}, {0.628701, 0.827512, 2.18681}, {0.124166, 0.127421,
1.}, {0.216377, 0.266915, 1.34211}, {0.434791, 0.615273,
1.99187}, {0.461743, 0.650073, 2.}, {0.47408, 0.849724, 2.}, {0.136915,
0.161205, 1.08425}, {0.28253, 0.481547, 1.7019}, {0.394007, 0.638609,
2.}, {0.413782, 0.799054, 2.}, {0.432252, 0.870749, 2.}}
Um etwas mehr „Übersicht“ über den grafischen Output zu erhalten, bietet es sich an, den
Plott dahingehend zu verändern, dass die Vektoren des SOM in ein kartesisches
Koordinatensystem mit den Daten eingetragen werden:
Show@Graphics[Join[
PlotAttributes[sampleData, Dims > {1, 2}, Goal > 3, PointSize > 0.005],
{GrayLevel[0]}, PlotSOMGrid[som, Dims > {1, 2}, Goal > 3, PointSize > 0.02, Thickness > 0.0025]
Als grafische Ausgabe sollte der Mathematica-Kernel das folgende Bild generieren:
-79-
Für die weitere Verarbeitung müssen die mit der SOM modifizierten Daten aus ihrem
Datenobjekt ausgelesen werden. Dafür bieten sich zwei Funktionen an.
Mit dem „som[]“ Befehl werden alle Daten aus der veränderten Datenmenge augelesen.
Mit der „RecallBM[]“ Funktion werden alle „Best Matches“ (beste Treffer) aus dem
Datensatz ausgegeben. Für die weiteren Arbeitsschritte ist der zweite Befehl der
geeignetere. Folgende Befehlszeile erledigt dies für das Beispiel:
recallData = RecallBM[sampleData, som, NStrength > 5.0, NSize > 5];
Hier ist der RecallBM[] noch einmal ein wenig genauer erklärt:
-80-
RecallBM[<datensatz>,<cluster>, <optionen>]
•
<datensatz>
•
<cluster>
•
<optionen>
•
•
•
Gewichtung:
Größe der Nachbarschaft:
Beeinflussung der Nachbarschaftsknoten:
Weights->Automatic oder Zahl
Nsize->Zahl
Nstrength->Zahl
Durch den folgenden Plot, in welchen aus dem bearbeiteten Datensatz alle „Best
Matches“ herausgefiltert wurden, sollte die Ausprägungen der Datensätze sichtbar
werden:
Show@Graphics[Join[
PlotAttributes[recallData, Dims > {1, 2}, Goal > 3, PointSize > 0.005],
{GrayLevel[0]}, PlotSOMGrid[som, Dims > {1, 2}, Goal > 3, PointSize > 0.02, Thickness > 0.0025]
Der grafische Output:
-81-
Anhand der Grafik ist ersichtlich, dass die erstellte “Self organized map” (SOM) das
Datenfeld beinhaltet. An den Ecken des Netzes ist eine höhere Dichte der Daten zu
erkennen. Dieser Effekt ist dadurch zu erklären, dass die Punkte, die zuerst außerhalb des
Netzes lagen, ins Netz abgebildet (“gemapped”) wurden.
7.3 Fuzzy K-Means (clustering)
Bei der Fuzzy K-Means-Methode handelt es sich um ein Clustering Verfahren, welches
die Möglichkeit bietet, die Zahl der Cluster frei zu wählen und jeden Vektor des zu
clusternden Datensatzes mit einer benennbaren Wahrscheinlichkeit (Nprototyp , den
sogenannten Prototypen) zu versehen. Der Fuzzy K-Means-Algorithmus sucht dabei nach
kreis- bzw. kugelförmigen Clustern im Merkmalsraum, welche die folgende Gleichung
minimieren:
U = Zugehörigkeitswahrscheinlichkeiten
V = Prototypen
dik = Distanz des k-ten Datenvektors zum i-ten Cluster
Der Exponent m in dieser Gleichung wird als „Fuzzyfizierer“ bezeichnet und gibt an,
wie stark der Zugehörigkeitsgrad des k-ten Datenvektors zu den einzelnen Clustern
"verwischt" wird (blured).
Aus dieser Gleichung geht ebenfalls hervor, dass es sich beim Fuzzy K-MeansAlgorithmus um ein Verfahren handelt, welches nach der "Batch-Methode" lernt. Die
Batch-Methode trainiert vollständig auf eine endliche Datenmenge. (z.B. trainiere
wiederholt auf 10 Episoden bis zur Konvergenz). Damit ist der Einsatz auf relativ kleine
Datensätze beschränkt, da sonst die benötigte Zeit zum Auffinden der Prototypen
unverhältnismäßig hoch werden würde. In der Regel muss mit der Terminierung des
Verfahrens in einem lokalen Minimum gerechnet werden. Somit ist die Initialisierung der
Prototypen ein sehr kritischer Punkt, welcher mit Sorgfalt betrachtet werden muß.
7.4 WARD (crisp clustering)
Das Clustern von Daten ist relativ einfach, wenn nur zwei Variablen vorhanden sind, da
ein zweidimensionaler Plot eine gute Visulisierungsmöglichkeit bietet. In der Industrie
und Wirtschaft benötigt man jedoch für komplexe Systeme öfter mehrdimensionale
-82-
Datenfelder, deswegen findet diese Methode in der Praxis eher wenig Anwendung.
7.4.1 Beispiel für WARD (crisp clustering)
Ausgehend von den Daten, die für die “Self organized maps” verwendet wurden, kann
auch ein “Clustering” mittels des WARD-Algorithmus durchgeführt werden. Hierzu wird
der CreateWARD[] Befehl benutzt.
CreateWARD[<datensatz>, <optionen>]
•
<datensatz>
•
<optionen>
•
•
•
Größe des Clusters:
Gewicht der Attribute:
Anfang des Zählers:
Size->Automatic oder Nummer
Weights->Automatic oder {x,y,...}
Count->Automatic oder Nummer
Für das Beispiel ergibt sich somit folgende Befehlszeile:
centersWARDinit = CreateWARD[
som,
Weights > {1, 1, 0},
Size > 1
];
Als Größe des Clusters wurde Eins gewählt, da die optimale Clusteranzahl zu diesem
Zeitpunkt nicht bekannt war. Da die Berechnung von WARD Clustern sehr viel
Rechenaufwand erfordern, empfehlen die Entwickler von MLF, dass “WARD
Clustering” nur in Zusammenhang mit “Self organized maps” (SOF) durchgeführt
werden soll.
Für das Beispiel hat der WARD-Algorithmus einen Valdierungs-Index von 13
verschiedenen Werten erzeugt. Jeder dieser Validierungswerte beinhaltet die
Wahrscheinlichkeit, dass ein Datensatz eine bestimmte Anzahl an Clustern beinhaltet.
Für das Arbeiten mit MLF hat sich herausgestellt, dass ein Validierungsindex von 1 bis
13 die besten Ergebnisse bei der Berechnung ergibt.
-83-
Um den Valdierungsindex sehen zu können, bietet sich die „PlotLineGraph[]“-Operation
an:
wIndex = GetParam[centersWARDinit, "WIndex"][[1]];
PlotLineGraph[wIndex];
Wie aus der Befehlszeile ersichtlich wird, muss zuerst der Index aus dem Cluster
extrahiert werden, bevor der Plot erzeugt werden kann . Dies geschieht mit der GetParam
[] Funktion. Der Output sieht folgendermaßen aus:
Für diese Grafik erzeugt der Kernel einen Plot, bei dem auf der Abszisse die
Clusteranzahl und auf der Ordinate die Validierungswerte eingetragen sind. Bei der
Betrachtung des Grafen sollte die Anzahl der Cluster, die am wahrscheinlichsten für den
Datensatz ist, erkennbar sein. Je höher der Validierungswert ist, desto größer ist die
Wahrscheinlichkeit für die jeweilige Clusteranzahl. Davon ausgehend wählt man die
Clusteranzahl mit dem höchsten Validierungswert, beziehungsweise nimmt man die
Spitzen des Grafs für die weiteren Berechnungen. (Bei diesem Beispiel ist der Cluster mit
der Größe vier sehr stark ausgeprägt)
Nachdem die Clustergröße vom Benutzer gewählt wurde, sind alle Vorbereitungen für
das Clustering abgeschlossen. Für die Durchführung des Clusterings bietet sich das KMeans-Clustering oder das WARD Clustering an. Für das Beispiel bietet keine der
beiden Methoden Vor- oder Nachteile, der Einfacheit halber wird im folgenden Abschnitt
das WARD – Clustering beschrieben.
Die WARD Methode bietet es an, den vorigen Output in Form eines Baumes
darzustellen:
Show[Graphics[PlotClusteringTree[centersWARDinit]], PlotRange > All];
-84-
Die Nummern am Boden des Baumes stellen die Nummern der Knoten dar. Man kann
dies auch als SOM darstellen lassen:
labels = Range[25] – 1;
Show@Graphics@
PlotSOMGrid[som, Dims > {1, 2}, Thickness > 0., Labels > labels, PointSize > 0.04, AspectRatio > 1];
-85-
Für die Berechnung des Clusters sollte die optionale Angabe der optimalen Clustergröße
dem Algorithmus mitgegeben werden:
optSize = Position[wIndex, Max@wIndex][[1, 1]];
centersWARD = CreateWARD[
som,
Weights > {1, 1, 0},
Size > optSize
];
Print["Computing ", optSize, " clusters."];
Der Mathematica-Kernel gibt aus, dass vier Cluster berechnet werden ( "Computing 4
clusters.") Dies ist nicht überraschend, denn in den vorigen Schritten könnte bereits aus
dem Indexgrafen erkannt werden, dass die optimale Clustergröße eine Anzahl von vier
Clustern aufweisen muss.
Der Cluster sollte auch durch einen Plott grafisch ausgegeben werden:
Show@Graphics[Join[
PlotAttributes[sampleData, Dims > {1, 2}, PointSize > 0.01],
{GrayLevel[0]}, PlotSOMGrid[som, Dims > {1, 2}, Goal > centersWARD, PointSize > 0.05, Thickness > 0.0025]
Als Output wird folgende Grafik erzeugt:
-86-
Ein Blick auf die erzeugten Cluster des WARD-Algorithmus zeigt, daß manche Knoten
am Rande ihrer zugehörigen Cluster liegen. Im WARD-Clustering kann jeder Knoten nur
einem Cluster zugeordnet werden, was unter Umständen beim Benutzer zu
Mißverständnissen führen kann. Um dieses Problem zu umgehen, sollten FuzzyClustering-Methoden verwenden werden, denn bei diesen Methoden kann ein Knoten zu
mehreren Cluster gehören.
Um ein solches Fuzzy-Cluster zu erzeugen, kann die k-means Methode verwendet
werden. Die Initialisierung erfolgt mittels der „CreateKMeans[]“ Operation.
CreateKMeans[<datensatz>, <optionen>]
•
<datensatz>
•
<optionen>
•
•
•
•
•
Größe des Clusters:
Gewichtung:
Anfang des Zählers:
Fuzzyfizierung des Clusters:
Einflußfaktor der SOM:
Weights-> Automatic oder Liste {x,y,...}
Count->Nummer
Fuzziness->Nummer
SomFactor->Nummer
Wie bereits an der Syntax ersichtlich wird, ist die k-means Methode sehr stark von der
Initialisierung abhängig. (Speziell durch den Fuzzyness- und den SOM-Einflußfakor.)
Angewendet auf das Beispiel ergibt sich folgende Befehlszeile:
centersKMeans = CreateKMeans[
sampleData,
Weights > {1, 1, 0},
Size > 4,
Fuzziness > 50.0,
SomFactor > 10.0
];
-87-
Die k-means Cluster werden durch die Angabe ihres Zentrums beschrieben. Es empfiehlt
sich, die Cluster vom Mathematica-Kernel als Matrix ausgeben zu lassen:
GetParam[GetParam[centersKMeans, "Clusters"], "DataMatrix"][[1]] // TableForm
Für eine übersichtliche grafisce Darstellung der Clustern ist es besser, wenn man sich des
„Show@Graphics[]“ Kommando bedient. In unserem Falle würde das folgendermaßen
aussehen:
Show@Graphics[Join[
PlotAttributes[sampleData, Dims > {1, 2}, Goal > centersKMeans, PointSize > 0.01]
], Axes > True, PlotRange > {{0, 1}, {0, 1}}];
-88-
7.5 Clusterberechnung mit verschiedenen Methoden
In der Praxis ist es oft sehr schwierig, die Anzahl der Cluster und deren Zentren
herauszufinden. Aus diesem Grund macht es Sinn, verschiedene Methoden zu
kombinieren, um ein optimales Ergebnis überhaupt erst erzielen zu können.
Im folgenden Beispiel wird die WARD Methode benutzt, um ein k-means-Clustering zu
initialisieren:
centersWARD = CreateWARD[
som,
Weights > {1, 1, 0},
Size > 3
];
som,
InitClusters > GetParam[centersWARD, "Clusters"],
Weights > {1, 1, 0},
Size > 3
];
Durch die obere Befehlszeile wird ersichtlich, dass die von der „CreateWARD[]“
Funktion erzeugten Cluster als Input für die Initialisierung der k-means-Cluster benutzt
werden. Mit der folgenden Funktions- und Operationskombination sollten die erzeugten
Cluster schließlich grafisch ausgegeben werden:
Show@Graphics[Join[
PlotAttributes[sampleData, Dims > {1, 2}, Goal > 3, PointSize > 0.005],
{GrayLevel[0]}, PlotSOMGrid[som, Dims > {1, 2}, Goal > centersKMeans, PointSize > 0.05, Thickness > 0.0025]
-89-
Als Plott wird folgende Grafik erzeugt:
Wenn erwünscht, kann daraus eine Beschreibung kreiert werden, wie wir sie schon aus
dem Bereich des „Supervised Learnings“ kennen:
sampleData,
Weights > {1, 1, 0},
Size > 4,
Fuzziness > 50.0,
SomFactor > 10.0
];
testPreds = CreatePredicates[sampleData, {1, 2}, 6];
testVars = DefPredicateVars[testPreds];
descr = CreateClusterDescriptions[sampleData, centersKMeans, testVars, MaxRules > 5];
PrintDescriptions[descr, Info > False]
-90-
7.6 Fazit
Die Kombination von „Unsupervised Learning“ mit „Supervised Learning“ ist optimal
für das Bearbeiten von Daten, die unvollständig sind oder bei denen das Ziel im
vorhinein noch nicht klar ist. Meist wird „Unsupervised Learning“ vor „Supervised
Learning“ benutzt, da dadurch einerseits Daten angeglichen werden, andererseits
eventuelle Ziele zum Vorschein kommen können.
Da medizinische Daten meist in unvollständiger Form vorhanden sind, macht die
Auswertung der Daten nur durch die Kombination „Unsupervised-Supervised Learing“
Sinn. Denn durch „Unsupervised Learning“ werden die Daten einerseits angeglichen
beziehungsweise vervollständigt, andererseits werden erste „verborgene“
Zusammenhänge zwischen den Daten sichtbarer.
Kurz gesagt bereitet „Unsupervised Learning“ die Daten auf, die dann durch „Supervised
Learning“ genauer in Betracht genommen werden können. Dadurch ist es möglich, die
-91-
vorhandenen Daten auf ein Minimum des Notwendigen zu reduzieren. Ein relativ großer
Nachteil bei diesen Verfahren ist, daß die Rechtenzeit exponentiell zu der Menge an
Daten ansteigt. Der Grund dafür liegt darin, daß die Berechnung der Cluster ein sehr
rechenaufwendiges Verfahren ist. Dadurch wird dieses Verfahren bei einer zu großen
Datenmenge wiederum unbrauchbar.
-92-
8 Kurzreferenz
Diese Referenz sollte die wichtigsten Kommandos im Zusammenhang mit MLF und
Mathematica kurz beschreiben und deren Syntax anführen. Sie sollte vor allem als
Nachschlagewerk für das Arbeiten mit MLF behilflich sein.
CreateSOM[]
Beschreibung:
Dient zum Erzeugen einer „Self Organized Map“. Es müssen dabei Daten angegeben
werden. Als Option können die Größe der SOM Matrix sowie Fehlerlevel, Typ und
Gewichtung der Attribute angegeben werden.
Syntax:
CreateSOM[<daten>, <optionen>]
• <daten>
• <optionen>
• Größe der SOM – Matrix:
Size->{x,y}
• Maximales Fehlerlevel:
Errorlevel -> Automatic oder Angabe einer Zahl
• Typ:
Wahlweise “BATCH” oder “ONLINE”
• Gewichtung der Attribute:
Weights->Automatic oder Weights->{x,y,...}
• Initialisierung des Zählers:
Count-> Automatic oder Angabe einer Zahl
RecallBM[]
Beschreibung:
Die sogenannte „Recall-Best Matches-Methode“ ruft die angepaßten Daten zurück. Es
müssen der Datensatz und die Cluster angegeben werden. Als Optionen stehen dann noch
die Gewichtung, die Größe der Nachbarschaft und die Beeinflussung der
Nachbarschaftsknoten zur Verfügung.
Syntax:
RecallBM[<datensatz>,<cluster>, <optionen>]
• <datensatz>
• <cluster>
• <optionen>
-93-
•
•
•
Gewichtung:
Größe der Nachbarschaft:
Beeinflussung der Nachbarschaftsknoten:
Weights->Automatic oder Zahl
Nsize->Zahl
Nstrength->Zahl
CreateWARD[]
Beschreibung:
Erzeugen eines WARD Clusters ausgehend von einem gewissen Datensatz. Hier können
Angaben über die Größe, Gewicht der Attribute und des Zählers mitgegeben werden.
Syntax:
CreateWARD[<datensatz>, <optionen>]
• <datensatz>
• <optionen>
• Größe des Clusters:
• Gewicht der Attribute:
Weights->Automatic oder {x,y,...}
• Anfang des Zählers:
Count->Automatic oder Nummer
CreateKMeans[]
Beschreibung:
Dient zum Erzeugen eines Fuzzy-Clusters mittels der k-means Methode. Hierbei muss
der Datensatz angegeben werden. Optionen über die Größe des Clusters, dessen
Gewichtung, Fuzzyfizierung und der Einflußfakor des SOM kann mitgegeben werden.
Syntax:
CreateKMeans[<datensatz>, <optionen>]
• <datensatz>
• <optionen>
• Größe des Clusters:
• Gewichtung:
Weights-> Automatic oder Liste {x,y,...}
• Anfang des Zählers:
Count->Nummer
• Fuzzyfizierung des Clusters:
Fuzziness->Nummer
• Einflußfaktor der SOM:
SomFactor->Nummer
-94-
CreatePredicates[]
Beschreibung:
Dient zum Erzeugen von Fuzzy-Prädikaten für numerische Datensätze. Dazu muss der
Datensatz, die Spalte und die Anzahl der Sets angegeben werden. Optionen über
Maximum, Minimum, Typ des Fuzzy-Sets und dergleichen können angegeben werden
Syntax:
CreatePredicates[<datensatz>, <Spalten> ,<anzahl der sets>, <optionen>]
•
•
<datensatz>
<optionen>
• Überlappung der Fuzzy-Sets:
• Breite des Fuzzy-Sets:
• Prädikattyp :
• Settyp:
• Minimum der Betrachteten Wertebereiche:
• Grenze:
• Sprachliche Variablen:
• Seperate Fuzzy-Set:
• Schnittpunkte:
• Minimum:
• Maximum:
Overlap -> Automatic oder Wert
Width -> Automatic oder Wert
PredType -> ALL oder IS oder ISEX
SetType -> PWL oder EXP
MinSup –> Automatic oder Wert
Border -> True oder False
Linguistic -> True oder False
SeparateSets -> True oder False
Cutpoints -> Automatic oder Wert
Minimum -> Automatic oder Wert
Maximum -> Automatic oder Wert
CreatePredicatesIs[]
Beschreibung:
Dient zum Erzeugen von Fuzzy-Prädikaten für nicht numerische Datensätze. Dazu muss
der Datensatz, die Spalte und die Anzahl der Sets angegeben werden. Optionen über
Maximum, Minimum, Typ des Fuzzy-Sets und dergleichen können angegeben werden.
Syntax:
CreatePredicatesIs[<datensatz>, <Spalten> ,<anzahl der sets>, <optionen>]
•
•
<datensatz>
<optionen>
• Überlappung der Fuzzy-Sets:
• Breite des Fuzzy-Sets:
• Prädikattyp :
• Settyp:
Overlap -> Automatic oder Wert
Width -> Automatic oder Wert
PredType -> ALL oder IS oder ISEX
SetType -> PWL oder EXP
-95-
•
•
•
•
•
•
•
Minimum der betrachteten Wertebereiche:
Grenze:
Sprachliche Variablen:
Seperate Fuzzy-Set:
Schnittpunkte:
Minimum:
Maximum:
MinSup –> Automatic oder Wert
Border -> True oder False
Linguistic -> True oder False
SeparateSets -> True oder False
Cutpoints -> Automatic oder Wert
Minimum -> Automatic oder Wert
Maximum -> Automatic oder Wert
CreatePredicateVars[]
Beschreibung:
Erzeugt zu der angegebenen Prädikatliste die dazugehörigen Prädikatvariablen. Dazu
muss eine Prädikatliste angegeben werden. Es gibt keine Optionen.
Syntax:
CreatePredicateVars[<datensatz>]
•
<datensatz>
CreateID3[]
Beschreibung:
Dient zum Erzeugen eines Entscheidungsbaumes mit dem FS-ID3 Algorithmus. Dazu
muss der Datensatz, die Prädikatenliste und die Zielliste angegeben werden. Optional
kann angegeben werden, welche Logik verwendet werden soll usw. .
Syntax:
CreateID3[<datensatz>, <pädikatenliste> ,<zilliste>, <optionen>]
•
•
•
•
<datensatz>
<prädikatenliste>
<zielliste>
<optionen>
• Verwendete Logik:
• Minimum Überlappung:
• Minimum Entropie:
Logic -> LogicM oder Angabe
MinConf -> Wert
MinSup -> Wert
-96-
•
•
Minimum Erhöhung der Entropie:
Maximale Baumtiefe:
MinIncr -> Wert
MaxLevel -> Wert
RecallID3[]
Beschreibung:
Dient zur Neuklassifizierung eines Datensatzes mit einem Entscheidungsbaum. Dazu
muss der Datensatz und ein Entscheidungsbaum angegeben werden. Optional kann die
verwendete Logik angegeben werden usw. .
Syntax:
RecallID3[<datensatz>, <pädikatenliste> ,<zilliste>, <optionen>]
•
•
<datensatz>
<entscheidungsbaum>
• Entscheidungstyp:
Type -> PROB oder MAJOR
CreateFOIL[]
Beschreibung:
Dient zum Erzeugen einer Regelbasis mit dem FS-FOIL Algorithmus. Dazu muss der
Datensatz, die Prädikatenliste und die Zielliste angegeben werden. Optional kann
angegeben werden welche Logik verwendet werden soll usw. .
Syntax:
CreateFOIL[<datensatz>, <pädikatenliste> ,<zielliste>, <optionen>]
•
•
•
•
<datensatz>
<prädikatenliste>
<zielliste>
<optionen>
• Minimum Detail:
• Minimum Vertrauen:
• Maximale Länge der Regeln:
MinSup -> Wert
MinConf -> Wert
MaxLevel -> Wert
-97-
•
•
•
Maximale Versuche nach Fehlschlag:
Maximale Anzahl der Iterationen
Bereich der Suche
MaxNegIter -> Wert
MaxIter -> Wert
ExpLevel -> Wert
RecallFOIL[]
Beschreibung:
Dient zur Neuklassifizierung eines Datensatzes mit einer Regelbasis generiert vom FSFOIL-Algorithmus. Dazu muss der Datensatz und eine Regelbasis vom FS-FOILAlgorithmus angegeben werden. Optional kann die verwendete Logik angegeben werden.
Syntax:
RecallFOIL[<datensatz>, <regelbasis>, <optionen>]
•
•
•
<datensatz>
<regelbasis>
<optionen>
Logik –> Angabe der Logik
CreateMINER[]
Beschreibung:
Dient zum Erzeugen einer Regelbasis mit dem FS-MINER-Algorithmus. Dazu muss der
Datensatz, die Prädikatenliste und die Zielliste angegeben werden. Optional kann
angegeben werden welche Logik verwendet werden soll usw. .
Syntax:
CreateMINER[<datensatz>, <pädikatenliste> ,<zielliste>, <optionen>]
•
•
•
•
<datensatz>
<prädikatenliste>
<zielliste>
<optionen>
• Minimum Detail:
• Minimum Vertrauen:
• Maximale Länge der Regeln:
MinSup -> Wert
MinConf -> Wert
MaxLevel -> Wert
-98-
•
Maximale Anzahl der Regeln:
MaxRules -> Wert
RecallMiner[]
Beschreibung:
Dient zur Neuklassifizierung eines Datensatzes mit einer Regelbasis generiert vom FSMINER-Algorithmus. Hierbei muss der Datensatz und eine Regelbasis vom FS-MINERAlgorithmus angegeben werden. Optional kann die verwendete Logik angegeben werden.
Syntax:
RecallFOIL[<datensatz>, <regelbasis>, <optionen>]
•
•
•
<datensatz>
<regelbasis>
<optionen>
Logik –> Angabe der Logik
OptimizeRENO[]
Beschreibung:
Dient zur Optimierung von gegebenen Regelbasen (erstellt von FS-MINER oder FSFOIL). Dazu muss ein Datensatz sowie eine Regelbasis angegeben werden. Optional
können auch die Spalten der Datenmengen angegeben werden usw.
Syntax:
OptimizeRENO[<datensatz>, <regelbasis>, <optionen>]
•
•
•
<datensatz>
<regelbasis>
<optionen>
• Inputattribute:
• Zielvariable:
• Art der Regelbasis
• Beta1
• Beta2
Dims -> {Werte, Werte}
Goal -> Wert
Automatic oder Angabe der Art
Automatic oder Angabe von „parameter beta 1“
Automatic oder Angabe von „parameter beta 2“
-99-
-100-
9 Literaturhinweise
Zu Mathematica
• Sanns, Schuchmann - Datenanalyse mit Mathematica – Oldenbourg 1999
• Michael Kofler, Hans-Gert Gräbe – Mathematica (Einführung, Anwendung, Referenz)
– Addison Wesley 2002
Zu Fuzzy-Logik
• Zadeh, L.: "Fuzzy Sets", Information and Control 8, 1965
• Schildt, G.-H.: Prozeßautomatisierung, Springer Verlag, 1998
• Jamshidi, M.: Applications of Fuzzy-Logik, Prentice Hall, 1997
Zu Superviced Learning
• Quinlan, J. Ross: Applications of Expert Systems: Based on the Proceedings of the
Second Australian Conference, Addison Wesley 1987
-101-

MLF - jvr.at

Transcrição

Documentos relacionados

Klinik Optimus in Breslau (Wroclaw)

Kardiovaskuläre Parameterveränderungen bei - Clue

HRZ Uni Bonn: Willkommen am Hochschulrechenzentrum der

530_R Eduardus-K_Köln.indd

NACHBEHANDLUNG nach FUSSOPERATIONEN

Operation an der Vorhaut (Beschneidung)

Verhalten nach Eingriffen an der Nase und

Korrektur der Augenlider

Operation an den Nasennebenhöhlen

Entfernung der Mandeln und ev. der Rachenmandeln