Entwicklungsmethodik, Ontologieentwurf und

Сomentários

Transcrição

Entwicklungsmethodik, Ontologieentwurf und
Entwicklungsmethodik, Ontologieentwurf und Wissensrepräsentation
für ein domänen-unabhängiges Recherchewerkzeug unter
Einbeziehung der Semantik von Recherchekontexten
Sachbericht
zu den Arbeiten des Projektpartners
Hochschule für Technik und Wirtschaft Dresden (FH)
H. Fritzsche, A. Kischkel, E. Lofing
18. Juli 2008
In dem vorliegenden Sachbericht werden die Teilleistungen der HTW Dresden (FH) als
beteiligte Forschungseinrichtung im Kooperationsprojekt „Domänen-unabhängiges
Recherchewerkzeug“ (Kurztitel) abgerechnet. Das Kooperationsprojekt wurde vom BMWi im
Programm PRO INNO II unter dem Förderkennzeichen KF 0435101SS6 im Zeitraum 1. März
2007 - 14. März 2008 gefördert.
Inhalt
1
2
3
Aufgabenstellung ............................................................................................................... 2
Abrechnung der Arbeitspakete........................................................................................... 2
Darstellung der erreichten Ergebnisse................................................................................ 4
3.1
Technologie (Entwicklungsmethodik, Wissensrepräsentation, Ontologieentwurf)... 4
3.2
Werkzeuge.................................................................................................................. 9
4
Verwertung der Ergebnisse .............................................................................................. 12
5
Einschätzung der Marktaussichten................................................................................... 12
6
Gemeinsame zukünftige Verwertung............................................................................... 12
7
Fortschreibung des Konzepts der Erfolgskontrolle .......................................................... 12
Literaturverzeichnis.................................................................................................................. 13
1
1 Aufgabenstellung
Recherchesysteme sind heute unverzichtbare Werkzeuge zum Auffinden von Informationen
in großen und heterogenen Datenbeständen (in Form von Dokumentensammlungen). Solche
Systeme orientieren nicht wie Content Management Systeme auf eine spezifische Verwaltung
und Archivierung von Datenbeständen, sondern nutzen bereits existierende Datenbestände
unterschiedlichster Art als Quellen. Das Vorhaben zielt auf die Schaffung eines
Prototypsystems einer Klasse von Recherchewerkzeugen, die es bisher am Markt nicht gibt
und die aus Recherchevorgängen selbst Informationen gewinnen, mit denen Anwender in
qualitativ neuer Weise in ihrer Arbeit unterstützt werden können.
Die von der HTW Dresden (FH) zu leistenden Arbeiten stehen in engem Zusammenhang mit
den vom Projektpartner Interface Projects GmbH im Kooperationsprojekt durchzuführenden
Entwicklungsarbeiten. Grundlage bildet das Recherchewerkzeug inter:gator der Interface
Projects GmbH. Das Werkzeug ist als Client-Server-Applikation realisiert. Der Client besitzt
ein Web-Portal. Metainformationen über indizierte bzw. recherchierte Dokumente werden
über eine zu definierende Schnittstelle des inter:gator-Clients aus einem Repository für die
Erstellung von Kontext-Modellen zugänglich gemacht und sind semantisch auszuwerten. Zu
unterschiedlichen Zeitpunkten erhaltene Metainformationen sind in einem dynamischen
Kontext-Modell zu speichern. Das Navigieren in „gespeicherten Zusammenhängen“ soll
unterstützt werden. Zur Unterstützung der Beschreibung und Verarbeitung von
Recherchekontexten ist ein Formalismus (Wissensrepräsentation) zu entwickeln und zu
definieren, der auch die Möglichkeit zur Speicherung und Nutzung von Ontologien
einschließt. Durch die Nutzung von semantischen Kontext-Modellen (Kontextsemantik) und
Ontologien sollen Recherchen mit der Client-Software qualifizierter als bisher realisiert
werden können. Ontologien sind für Fallbeispiele zu entwerfen. Erfahrungen von P. Schnupp
mit dem von ihm entwickelten Omni-Composer/Omni-Manager sollen für die Erstellung von
Kontextsemantiken einfließen und werden über Aufträge realisiert. Gewonnene
Kontextinformationen sollen dynamisch, d.h. zur Laufzeit in die Metadatenbasis des
inter:gator-Systems integriert und im Rechercheprozess nutzbar gemacht werden können.
2 Abrechnung der Arbeitspakete
Es wurden folgende Arbeitspakete (AP) gemäß Projektantrag bearbeitet und termingerecht
(einschließlich kostenneutraler Verlängerung) abgeschlossen:
1.
2.
3.
4.
5.
Entwicklungsvorbereitung und Erstellung eines detaillierten Pflichtenheftes
Wissenschaftliche Untersetzung der Beschreibungsmethodik
Theoretische Analyse zu abstrakten Kontextsemantiken
Entwurf einer Ontologie
Unterstützung bei der Entwicklung von Funktionalitäten spezieller Komponenten der
Systemarchitektur
6. Wissenschaftliche Auswertung der Testverfahren, Unterstützung bei der Optimierung
Im AP 1 wurde neben einer fachlichen Analyse des aktuellen Arbeitsstandes auf dem Gebiet
des Information Retrieval (IR) insbesondere gemeinsam mit der Interface Projects GmbH die
Schnittstellenproblematik des Systems inter:gator untersucht. Die Projektmitarbeiter der
HTW Dresden wurden mit der inter:gator-Problematik vor Ort vertraut gemacht. Detaillierte
und mit den Arbeitspaketen des Projektpartners abgestimmte Zielstellungen wurden in einem
Pflichtenheft erfasst und konkrete Arbeitsschritte für die Mitarbeiter abgeleitet [FKL07].
2
Diese Vorgehensweise entsprach Empfehlungen der modernen Softwaretechnologie [Som07].
Das AP wurde bis zum 20.04.2007 abgeschlossen.
Die Beschreibung von Metadaten und Recherchekontexten muss auf dynamischen
Datenstrukturen aufbauen, da sich Objektmengen und Zusammenhänge im Laufe von
Recherchen mit der Zeit verändern. Im AP 2 wurde deshalb als eines der wesentlichen
Arbeitsergebnisse ein Formalismus zur Wissensrepräsentation als Beschreibungsmittel für
Kontext-Modelle und Ontologien definiert (die Nachnutzung der in einzelnen existierenden
Entwicklungsumgebungen angebotenen Beschreibungsmittel erwies sich als zu unflexibel).
Ein solcher Formalismus ist eine formale Sprache, wobei auch Programme zu deren
Interpretation einbezogen sind. Es wurde eine Horn-Klausel-Repräsentation unter
Zugrungelegung der Syntax einer Listennotation entsprechend der Programmiersprache
Scheme [Dyb87] festgelegt. Ein vom Projektleiter früher entwickelter Scheme-Interpreter
wurde im Rahmen des Kooperationsprojektes angepasst und verfügbar gemacht [FL08].
Damit ist eine hohe Variabilität bzgl. der Horn-Klauselverarbeitung geschaffen worden und es
gibt es keinerlei Lizenzprobleme. Weitere Angaben zur Wissensrepräsentation sind im
Abschnitt 3.1 enthalten. Das AP 2 wurde bis Ende 06/2007 abgeschlossen.
Im AP 3 wurde untersucht, was Recherchekontexte sind und wie sie zu beschreiben sind.
Vom inter:gator-Client wird auf Anforderung ein inter:gator-Modell aufgebaut und
exportiert. Die in diesem extern mittels RDF repräsentierten Modell enthaltenen
Metainformationen wurden klassifiziert. Eine Eigennamenerkennung ist integriert. Aus
Beispielen konnten Erkenntnisse über praktisch vorkommende Inhalte und Metadaten
gewonnen werden. Davon ausgehend wurden typische Prädikate definiert (z.B. Person,
Vertrag etc.). Allgemeingültige Beziehungsinformationen (Klasse-Instanz-Beziehung,
Generalisierungs-Spezialisierungs-Beziehungen, Teil-Ganzes-Beziehungen, vgl.
Projektantrag) wurden mit Klauseln (Regeln) beschrieben. Das AP 3 wurde teilweise
überlappend mit AP 2 bis Ende 09/2007 bearbeitet und erforderte einen intensiven Austausch
mit dem Kooperationspartner.
Im AP 4 wurden beispielhaft Ontologien unter Nutzung des in AP 2 beschriebenen
Formalismus erstellt. Dabei handelte es sich um Lösungen zu den Anwendungsgebieten
Projektmanagement Geschäftsprozesse im Dekanat einer Hochschule. Das Fallbeispiel
„Wissen von Sachverständigen für Softwaretechnik“ wurde überwiegend der Interface
Projects GmbH zugeordnet. Die Arbeiten wurden bis 11/2007 durchgeführt, wurden aber auch
später im Rahmen der anderen Arbeitspakete noch inhaltlich aktualisiert.
Im AP 5 wurden benötigte Werkzeuge entwickelt und beschrieben. Dabei wurden an der
HTW Dresden bereits geleistete Vorarbeiten fortgesetzt. Das Programmiersystem JamusScheme, das im Kontext des Projektes als Implementierungsbasis für die Programme zur
Interpretation von Kontext-Modellen verwendet wird, wurde erweitert und dokumentiert
[FL08]. Es wurde ein Horn-Klausel-Interpreter in Jamus-Scheme entwickelt. Durch die
Eigenentwicklung wurde es möglich, unterschiedliche Interpretationsstrategien (vorwärts
verkettend, rückwärts verkettend) zu realisieren. Auf der definierten formalen Sprache
aufbauend wurde als wichtigstes Ergebnis ein Klassifikator für Dokumente entwickelt. Alle
entwickelten Werkzeuge wurden in einer Programmdokumentation beschrieben [LF08]. Die
Werkzeugentwicklung erfolgte parallel zu den Arbeitspaketen 2, 3 und 4 und wurde 11/2007
wesentlich abgeschlossen. Im AP 6 ergaben sich Korrekturen und Erweiterungen im Verlaufe
der Testung.
Im AP 6 wurden Beispiele von Kontext-Modellen erprobt (getestet). Dabei wurden Szenarien
für das Navigieren in Kontext-Modellen entwickelt. Durch die Nutzung der entwickelten
Werkzeuge konnten implizit bekannte Sachverhalte explizit dargestellt und
Schlussfolgerungen gezogen werden. An diesem AP 6 wurde bis Projektende 02/2008
3
(einschließlich kostenneutraler Verlängerung) gearbeitet. Die Zielstellung wurde erfüllt. es
wurden weiterführende Ziele abgesteckt. Diese betreffen insbesondere die Einbindung von
Metainformationen über Recherchekontexte in die Funktion von inter:gator-Clients.
3 Darstellung der erreichten Ergebnisse
Nachfolgend wird zunächst die im Projekt erarbeitete und umgesetzte Technologie für den
Umgang mit Kontextinformationen und Metadaten erläutert. Im Anschluss daran werden die
verwendeten und im Rahmen des Projekts entwickelten und erprobten Werkzeuge
beschrieben.
3.1 Technologie (Entwicklungsmethodik, Wissensrepräsentation,
Ontologieentwurf)
Durch die Interface Projects GmbH wurde im Rahmen des geförderten Kooperationsprojektes
u.a. ein neuer Typ von inter:gator-Client entwickelt. Instanzen dieses Typs können mit
einem inter:gator-Server kommunizien. Der Client kann über ein Web-Portal genutzt
werden:
Die an der HTW Dresden prototypisch entwickelte Software bildet zunächst eine
eigenständige Applikation, kann aber aufgrund der einheitlich für die Implementierung als
Basis benutzten Programmiersprache Java [G+05] später in den inter:gator-Client integriert
werden (Plug-in-Technologie). Die an der HTW Dresden entwickelte Software kann
4
grundsätzlich mit der inter:gator-Client-Software über eine von dieser bereitgestellten
Schnittstelle (API) zusammenarbeiten. Zur Realisierung der Speicherung von Metadaten wird
im inter:gator-Client das Jena-Framework eingesetzt [Jena]. Das Framework implementiert
RDF sowie DAML+OIL.
Das Ziel von Recherchen mit einem Retrieval-System wie dem inter:gator ist das gezielte
Auffinden von Dokumenten in großen Dokumentbeständen. Nachdem ein Dateisystem –
dieses repräsentiert einen Dokumentenbestand - vom inter:gator-Server indiziert wurde, kann
der inter:gator-Client über seine Admin-Konsole unter Bezugnahme auf einen serverseitig
verwalteten Index ein inter:gator-Modell in externer Repräsentation in Form einer RDF-Datei
[RDFW3C, RDF06] erzeugen (intergator-model.rdf).
Das inter:gator-Modell ist der Ausgangspunkt für die Erfassung und Verarbeitung von
Textinhalten und Metadaten durch die an der HTW entwickelten Werkzeuge. In inter:gatorModellen werden u.a. Namensräume unterschieden. Innerhalb eines intergator-Modells sind
Beschreibungen einzelner Dokumente strukturell abgegrenzt. Typische Metadaten zu einem
Dokument sind Dateiname, Dateiextension, der im Ergebnis von Recherchen gelieferte
Quellpfad zur Dokumentquelle (URI), der Autor sowie im Dokument enthaltene Phrasen und
Schlüsselworte.
Auf der Grundlage des in AP 2 definierten Formalismus wird eine Wissensbasis weitgehend
durch die ebenfalls im Projekt entwickelten Werkzeuge aus inter:gator-Modellen erstellt.
Entwicklungsmethodik
Unterschiedliche Möglichkeiten zur Verarbeitung von inter:gator-Modellen wurden
untersucht. Dazu wurden frei verfügbare Software-Werkzeuge erprobt. In einer das Projekt
begleitenden Diplomarbeit von Christian Gnüchtel wurden insbesondere auch frei verfügbare
Komponenten für die Analyse von textuellen Inhalten analysiert [Gnü08].
In die Arbeiten zur Entwicklungsmethodik flossen auch die von E. Wagner und P. Schnupp
erbrachten Leistungen ein [Ws07]. Der von P. Schnupp entwickelte Omni-Manager diente als
Referenzsystem und beeinflusste insbesondere die Arbeiten zu Kontext-Modellen und
Ontologien. Kontextinformation wird während einer Sitzung mit dem inter:gator-Client durch
Nutzereingaben (textuell bzw. ereignisgesteuert bei Betätigung interaktiver Elemente)
aufgebaut. Die Nutzung von Kontext-Modellen dient u.a. der Selektion (Ausblendung) für
Nutzer nicht relevanter Informationen. In Kontext-Modellen gespeicherte Informationen
können im Kontext von Anfragen wieder verwendet werden, müssen also nicht erneut
eingegeben werden.
Die wesentlichen Werkzeuge wurden in Prolog deklarativ programmiert, eine eigene
Wissensrepräsentationssprache wurde definiert und ein flexibler und erweiterbarer Interpreter
in Jamus-Scheme programmiert. Da Jamus-Scheme selbst in Java implementiert ist und auch
eine Schnittstelle (API) zu Java besitzt, kann der gesamte Wissensrepräsentationsformalismus
von Java-Applikationen genutzt werden. Andererseits können auf der Basis von Java
Erweiterungen vorgenommen werden, so z.B. die Verbindung zu Persistenz-Frameworks
(Hibernate) oder die Anbindung an Datenbanksysteme wie etwa MySQL. Durch die
Verwendung von Scheme können wegen der Eigenschaften dieser Sprache (z.B. Funktionen
als Objekte erster Ordnung, lexikale Bindung) Objektstrukturen als Basis von
Wissensstrukturen dienen. Eine entsprechende „hybride“ Softwareentwicklungsumgebung ist
von H. Fritzsche implementiert und beschrieben worden [Fri94].
Zu Testzwecken wurde während der Entwicklung der Programmkomponenten die frei
verfügbare Entwicklungsumgebung SWI-Prolog eingesetzt [Wie03]. Dieses System erfordert
für die Notation der Prolog-Programme eine spezielle Syntax und stellt eine Vielzahl
5
nutzbarer Prädikate bereit. Genutzt wird u.a. auch die Fähigkeit dieses Prolog-Systems,
Wissensstrukturen in einer dynamischen Clause-Datenbank zu speichern.
In Kontext-Modellen kann mittels Prolog-Anfragen recherchiert werden. Ergebnisse von
Anfragen können leicht wiederum in Klauselform gespeichert werden.
Wissensrepräsentation
Der von uns verwendete Formalismus zur Wissensrepräsentation basiert auf der
Prädikatenlogik 1. Stufe (FOL) [KB07, Hod01]. Wissen wird in Form von Horn-Klauseln
dargestellt. Klauseln können Fakten, Regeln oder Anfragen sein. Die Prädikatenlogik ist gut
geeignet zur Darstellung von Fakten (Sachverhalten) und Inferenzregeln, wenn eine zur
Bildung von Ausdrücken geeignete Menge von Funktionen und Prädikaten bereitsteht.
Prädikate dienen der Darstellung von Relationen [Tan90].
In der externen Repräsentation von Horn-Klauseln wird von uns neben der von SWI-Prolog
unterstützten Notation parallel eine Listendarstellung verwendet. Die Syntax der
Listendarstellung entspricht der Scheme-Syntax [R3RS]. Da in Scheme (in Lisp allgemein)
syntaktisch kein Unterschied in der Repräsentation von Daten und Programmen existiert, lässt
sich der in Scheme implementierte Interpreter unmittelbar anwenden.
In der definierten Sprache sind folgende Arten von Bezeichnern verfügbar:
Konstantensymbole (als Symbole, Zahlen oder Strings in Scheme dargestellt),
Variablensymbole (als Scheme-Symbole dargestellt),
Prädikatsymbole und Funktionssymbole (mit klein geschriebenen Scheme-Symbolen
dargestellt).
Funktionssymbolen und Prädikatsymbolen sind jeweils eine Stelligkeit zugeordnet, die die
Anzahl der Argumente angibt.
Objekte eines Grundbereiches werden durch Terme bezeichnet.
term
→ konstantensymbol
|
variablensymbol
|
( funktionssymbol [ term ... ] )
prädikat → (prädikatsymbol [ term … ] )
Die Menge der logischen Symbole: { not, and, or}
atom
→ prädikat
literal
→ atom | ( not atom )
Eine Klauselmenge wird als Liste von Klauseln dargestellt.
Jede Klausel wird als Liste von Literalen dargestellt. Das 1. Element dieser Liste repräsentiert
ein nicht negiertes Literal, alle anderen Elemente repräsentieren negierte Literale. Negierte
Literale sind implizit and-verknüpft.
Ein Ziel (eine Anfrage) wird ebenfalls als Liste von Literalen notiert und soll nicht mit einem
Element einer Klauselliste verwechselt werden können.
Ein Beispiel zur Klauselinterpretation enthält der Abschnitt 3.2.
Ontologieentwurf
Grundsätzlich sind unterschiedliche Techniken zur internen) Speicherung von Ontologien als
dynamische Datenstrukturen realisierbar:
6
1. Bei der Ausführung übersetzter Java-Programme entstehen HS-intern Objekt-Strukturen,
die sich während der Laufzeit der Programme verändern (z.B. Erzeugung von Objekten,
Zustandsänderungen). Schnappschüsse von Objektstrukturen können durch Serialisierung
extern abgelegt, d.h. persistent gemacht werden. Objektstrukturen können durch
Deserialisierung wieder hergestellt werden. In diesem Sinne wären Klassen in einer
Ontologie durch Java-Klassen zu implementieren. Elemente der Ontologie wären als
Instanzen solcher Klassen realisiert. Beziehungen sind über Instanzvariablen („benutzt“Beziehung) zu modellieren.
Java-Programme können sich selbst untersuchen: Für Teile der Strukturen können
Graphen erzeugt werden, und diese können weiter verarbeitet werden.
2. Ein Quellprogramm (einer formalen Sprache) kann geparst werden, wobei ein
Syntaxbaum entsteht (Ebene M1). Dabei gibt es spezielle Klassen zur Repräsentation von
Baum-Knoten (abstrakte Syntax). Ein Syntaxbaum kann
-
transformiert werden (z.B. in Java-Bytecode)
-
„gerendert“ werden (Ausgabe Quelltext)
-
interpretiert werden, das bedeutet abgearbeitet (symbolisch!).
Syntaxbäume können als DOM-Bäume repräsentiert werden. In diesem Fall kann das
Parsen durch Xerxes erfolgen.
3. Es werden Symbole zur Realisierung von Kategoriebezeichnungen verwendet.
Eigenschaften werden mit Hilfe von Prädikaten (und Funktionen) beschrieben.
Im Projekt wurden die Ansätze 2 und 3 verfolgt. Ansatz 1 erschien nach Analyse zu
aufwändig.
Ontologien sind typischerweise branchenspezifisch, und sie beschreiben Sachverhalte aus
mehreren Modellebenen (M0 – M3) bzw. auch ebenenübergreifend [R3RS].
Ontologien werden nicht ausschließlich als Datenstrukturen betrachtet. Sie sind formale
Systeme und werden so auch genutzt. Anfragen und Inferenzen sind möglich. Mittels
Editoren automatisch durch vorwärts verkettende Inferenz-Strategien können Ontologien
erweitert werden.
Klassen werden mit Hilfe eines Klassifikator-Werkzeuges gebildet.
Beispiel 1: Ermittlung aller in einem inter:gator-Modell erfassten Vertäge, d.h. aller
Intanzen zur Klasse Vertrag. Es wird zu jedem Dokumentnamen eine
Gewichtsangabe bestimmt.
2 ?- load_test('RBC/intergator-model.rdf'), vertrag(X, Rank).
X =
docname(['file:/M:/work/Inter=Project/Test%20Ordner/Sortierte%20Dokumente/
Tutorial/Introduction.htm'])
Rank = 0.5
Yes
2 ?-
...
Das Prädikat load_test realisiert als Seiteneffekt das Parsen des inter:grator-Modells.
Im Prädikat vertrag/2 ist definiert, was ein Vertrag ist. Die Variable X wird an Namen
von Dokumenten gebunden, die die festgelegten Eigenschaften besitzen. Alle möglichen
7
Bindungen der Variablen X werden ausgegeben (eine sehr große Anzahl). Die benannten
Dokumente sind gemäß der in der Ontologie vorhandenen Beschreibung „Verträge“.
Beispiel 2: Die Namen aller Dokumente ermitteln, die Verträge sind, und die Namen der
Vertragspartner auflisten:
4 ?- load_test('RBC/intergator-model.rdf'),
vertrag(X, _),
metadata(X, _, _, _, persons(Persons), _, _).
X =
docname(['file:/M:/work/Inter=Project/Test%20Ordner/Sortierte%20Dokumente/
Tutorial/Introduction.htm'])
Persons = ['Engler, Hendrik', 'Naughton, Patrick', 'Joy, Bill',
'Andreesen, Marc']
Yes
5 ?-
...
Im Beispiel werden mögliche Bindungen der Variablen X an Dokumentnamen ausgegeben.
Dokumentnamen werden durch den Quellpfad des Dokuments dargestellt. Die im jeweiligen
Vertrag benannten Personen werden namentlich in einer Liste zusammengestellt.
Zum Aufbau von Ontologien wurden die Erfahrungen von P. Schnupp einbezogen.
Entsprechende Leistungen sind im Kooperationsprojekt vertraglich gebunden worden (FuEFremdleistung). Die folgende Abbildung zeigt einen Ausschnitt der grafischen Oberfläche des
von ihm entwickelten Omni-Managers.
Die in Beispiel 1 und Beispiel 2 verwendeten Beschreibungsmittel zeigen Individuen
(Instanzen) als Variablenwerte oder Konstanten, Prädikate stehen für Klassennamen. Auf den
Ebenen M1 – M2 werden Beziehungen ebenfalls durch Prädikate dargestellt. Im Prädikat
8
class( ′Vertrag′) ist die Klassenbezeichnung Instanz der Metaklasse ′class′.
Das Wechseln der Abstraktionsebenen ist bei Anwendung des von uns unterstützten
Wissensrepräsentationsformalismus sehr gut möglich, alle Strukturierungsvorgänge können
auf der Grundlage von Klauseln mit einem einzigen Interpretationsalgorithmus zur Laufzeit
verarbeitet werden.
Anhand der Ontologie können z.B. Hinweise auf weitere Subklassen zu Verträgen gegeben
werden. Solche Hinweise in Form von Fakten und Regeln sind für spätere Recherchen sehr
nützlich. Man denke in diesem Zusammenhang an die Strukturierung des Systems Wikipedia
(http://de.wikipedia.org/), das eine Navigation in der M2-Ebene unterstützt.
Hervorzuheben ist, dass Ontologien von Benutzern (Wissensarbeitern) überwiegend implizit
zu benutzen sind. In Ontologien erfasste Zusammenhänge zwischen unterschiedlichen
Abstraktionsstufen werden Nutzern als Assoziationen oder Handlungsvorschläge angeboten.
Im Geschäftsprozess einer Hochschulverwaltung beispielsweise wird ein Kooperationsvertrag
mit einer ausländischen Partnerhochschule einerseits der Thematik „Internationale
Beziehungen“ zuzuordnen sein, andererseits der Thematik „Verträge“. Im Moment der
Handhabung (z.B. Ablage) eines konkreten Vertrages (Instanz) spielen Probleme der
Kategorisierung eine untergeordnete Rolle (der Ordner „Internationale Beziehungen“ existiert
bereits), wohl aber in einem Geschäftsprozess der Organisation der Verwaltung (z.B. bei
Übernahme einer Funktion durch eine Person, der Ordner wird angelegt). Während der
Organisation (Metaebene) spielen wiederum Vertragsinhalte einzelner Verträge keine Rolle.
Eine während der Projektbearbeitung erkannte und künftig wissenschaftlich zu bearbeitende
Problematik bzgl. Ontologien ist die formale Beschreibung von zeitlichen Abläufen mittel
nicht-klassischer Logik (modale und temporale Logiken).
3.2 Werkzeuge
Klassifikator
Es wurde ein regelbasierter Klassifikator entwickelt (Constructor im Sinne der
Systemarchitektur des Projektantrages). Die Aufgabe des Klassifikators besteht darin,
Dokumente nach vorgegebenen Regeln zu klassifizieren. An Hand der Regeln können
Dokumente einer bestimmten Klasse nachgefragt werden. Geliefert werden u.a. die
Dokumentnamen aller zur Klasse gehörenden Dokumente, die im inter:gator-Modell
enthalten sind. Der Klassifikator beinhaltet einen RDF-Parser zur Erzeugung eines (internen)
Kontextmodells.
Die Interpretation der Regeln erfolgt durch einen Horn-Klausel-Interpreter in Verbindung mit
einer Faktenbasis.
Der in SWI-Prolog realisierte Klassifikator besteht aus einem Main-Modul, der seinerseits
die Module Rules, Utils und Token. verwendet (konsultiert).
Der Main-Modul (Prolog-Syntax) realisiert das Parsen einer RDF-Datei, die ein inter:gatorModell enthält. Zum Parsen wird die SWI-Erweiterungsbibliothek library(sgml)
verwendet. Die enthaltene Funktionalität unterstützt das Parsen SGML-basierter als auch
XML-basierter Sprachen (darunter RDF). Es werden Informationen über das Dokument selbst
und seine Dokumenttyp-Definiton (DTD) geliefert.
Der Parse-Vorgang wird mit dem Prädikat load_test/1 realisiert. Das Parsen erfolgt im
Main-Modul ereignisgesteuert, was besonders vorteilhaft bei größeren Dokumenten ist.
Folgende Auslöser-Reaktionstabelle gibt einen groben Überblick über den Parse-Vorgang.
9
Auslöser/Ereignis
Anfang der RDF-Datei
Anfang des ID-Elementes eines der
indizierten Dokumente
Anfang eines Person-Elementes eines der
indizierten Dokumente
Anfang eines Keyword-Elementes eines der
indizierten Dokumente
Anfang eines Format-Elementes eines der
indizierten Dokumente
Ende eines der indizierten Dokumente
Reaktion
Alle Metadaten aus der internen Prolog-DB
löschen
Den Wert des ID-Elementes in die PrologDB eintragen
Den Wert des Person-Elementes in die
Prolog-DB als eine Liste eintragen
Den Wert des Keyword-Elementes in die
Prolog-DB als eine Liste eintragen
Den Wert des Format-Elementes in die
Prolog-DB eintragen
Aus den in der Prolog-DB gespeicherten
Einzeleinträgen wird ein strukturierter
Dokumenten-Metadaten-Fakt generiert und
in die Prolog-DB eingetragen. Die benutzten
Einzeleinträge werden anschließend gelöscht.
Die auf diese Weise erstellte Metadaten-DB enthält die wichtigsten verwertbaren Metadaten
aller vom inter:gator indizierten Dokumente. Bei Benutzung der dynamischen SWI-PrologDatenbank werden Daten ausschließlich im Arbeitsspeicher gehalten. Zum
Hinzufügen/Entfernen von Klauseln stehen die Prädikate assert/1, retract/1 und
retractall/1 zur verfügung. Beim Eintragen in die Datenbank werden Klauseln
compiliert.
Die Benutzung des Klassifikators kann in zwei Rollen erfolgen:
Aus Sicht eines recherchierenden Benutzers (d.h. eines „Wissensarbeiters“,
vgl. [Ws07])
Aus Sicht eines Regeladministrators, der Klassifikationsregeln erstellt. Anhand
der Klassifikationsregeln werden Dokumente Klassen zugeordnet
(Konfiguration des Systems im Sinne der Systemarchitektur).
Der Rules-Modul wird vom Regel-Administrator erstellt und enthält Beschreibungen von
Klassen und Beziehungen. Beispiele für Klassen sind Vertrag, Mietvertrag,
Beschwerdeschreiben etc. Dieser Modul dient wesentlich zur Speicherung von
Ontologien.
Beispiel 3: Klassifikationsregel für die Definition von Verträgen:
vertrag(X, Rank) :document(X),
word(X, 'vertrag', 1, G1),
persons(X, 2, 1, G2),
average([G1, G2], Rank).
Die einzelnen Merkmale der Regel werden mit Gewichten versehen, dadurch ist es möglich,
einen Rang der Ergebnisse zu berechnen.
Der Keyword-Gen-Modul enthält einen Keyword-Generator, der anhand von vorhandenen
Regeln eine Liste der in den Regeln verlangten Keywords (das sind semantisch relevante
Keywords) generiert. Diese Erzeugung wird notwendig, weil die im inter:gator-Modell
10
enthaltenen und statistisch generierten Keywords häufig unbrauchbar für eine semantische
Klassifizierung sind. Die intergator-Keywords sind aus semantischer Sicht nicht die
wichtigsten Wörter, sondern die am häufigsten vorkommenden. Die meisten semantisch
relevanten Wörter fehlen. Der Keyword-Gen-Modul konsultiert den Rules-Modul.
Keyword-Merkmale wie z.B. in word(X, 'mieter', 1, G1) sind Case-insensitiv,
d.h.: ‚Mieter’ = ‚mieter’. Es wird auch eine Suche mit Teilzeichenketten durchgeführt. Zum
Beispiel ist word(X, ‚miet’, 1, G) auch für Keywords wie „Mietvertrag“,
„Vermieter“, „mieten“ usw. gültig.
Der Token-Modul definiert die Prädikate exists/1, document/1 und word/4.
document/1 und word/4 beziehen sich auf das Prädikat metadata/7. metadata/7
identifiziert ein Meta-Datum in der Prolog-Datenbank.
Der Utils-Modul enthält Prädikate, die zur Verarbeitung von Zeichenketten und Listen
benötigt werden, aber keine Standard-Prädikate sind (z.B. ein Prädikat average/2 zur
Berechnung des Mittelwertes einer Liste numerischer Werte).
Horn-Klausel-Interpreter
Es wurde ein Horn-Klausel-Interpreter entwickelt. Er basiert auf den Publikationen von H.
Fritzsche [Fri94] und H. Stoyan [Sto88]. Praktische Aspekte der Prolog-Programmierung
werden von P. Schnupp und K. Höß beschrieben [SH89].
Wesentliche Bestandteile des selbst entwickelten Horn-Klausel-Interpreters sind ein
Unifikations-Algorithmus (inklusive einer Implementierung des Occur-Check) und die
Klauselverarbeitung nach dem Prinzip der Resolution (Resolventenbildung nach Robinson).
Das nachfolgende Beispiel demonstriert den Horn-Klausel-Interpreter.
Beispiel 4: Das Programm prolog interpretiert die Anfrage (goal) in Bezug auf eine
Klausel-Menge (clauses).
(prolog
; clauses
'(
((intersect (cons X Y) Z (cons X U))
(member X Z)
(intersect Y Z U))
((intersect (cons X1 Y1 ) Z1 U1)
(intersect Y1 Z1 U1))
((intersect nil Y3 nil))
((member X2 (cons X2 Y2)))
((member Z2 (cons U2 V2))
(member Z2 V2))
)
; goal
'(
(intersect (cons a (cons b (cons c nil)))
(cons c (cons d (cons a nil)))
H))
)
=> ((H cons a (cons c nil ) ) )
Das erhaltene Resultat entspricht dem erwarteten Wert H = (a b).
11
Konverter
Ein von E. Lofing entwickeltes Konverter-Programm benutzt einen SAX-Parser [SAX] und
kann damit eine Transformation der externen RDF-Darstellung des Modells in eine interne
Darstellung und in der Folge in eine externe Scheme-Darstellung [R3RS] vornehmen.
4 Verwertung der Ergebnisse
Die Ontologie-Thematik wird im Rahmen des inter:gator-Projektes sowohl durch die
Interface GmbH als auch durch die HTW Dresden weiter verfolgt, da sie noch viel
Innovationspotential enthält. Zu dieser Thematik wird gegenwärtig eine Diplomarbeit
angefertigt (Herr S. Janosch).
Auch wenn das Produkt inter:gator weiterhin kommerziell durch die Fa. Interface Projects
GmbH vertrieben wird, sind die an der HTW Dresden erarbeiteten Programme auch im
Kontext der an der Hochschule verfolgten Forschungslinien unmittelbar nutzbar.
Die Nutzung erfolgt z.B. im Rahmen der Etablierung eines Wissenschaftsnetzwerkes mit
einer Plattform in der HTW Dresden als zentralem Knoten. Eine solche Plattform kann z.B.
im Rahmen von Diplom-/Bachelor-/Master-Abschlussarbeiten erbrachte wissenschaftliche
Leistungen kommunizieren und nutzbar machen. In diesem Kontext spielen Recherchen auf
der Basis von Ontologien eine zentrale Rolle.
5 Einschätzung der Marktaussichten
Die Marktaussichten des Gesamtsystems inter:gator haben sich durch die Erweiterung des
inter:gator-Clients und die Bearbeitung der Thematik Kontextsemantik deutlich verbessert.
Durch die von der HTW Dresden geleisteten Beiträge zur Modellierung von
Recherchekontexten und die Entwicklung von Ontologien können Recherchen zielgerichtet
unterstützt werden. In der Hochschule wird damit auch das Potential für weitere
Forschungsprojekte gestärkt.
6 Gemeinsame zukünftige Verwertung
Der HTW Dresden wurde im Juli 2007 von der Interface GmbH eine Lizenz der RetrievalSoftware inter:gator zur Verfügung gestellt. Die Ergebnisse des Kooperationsprojektes
werden künftig durch die Interface GmbH und die HTW Dresden gleichermaßen genutzt.
Eine gemeinsame Weiterentwicklung ist vorgesehen. Dabei wird es darum gehen, die
experimentellen Ergebnisse der Arbeit mit Kontext-Modellen und Ontologien in der
Metadatenverwaltung des inter:gator praktisch zu nutzen. Durch Forschungsarbeiten an der
Hochschule sollen auch neue Anwendungsgebiete für Ontologien erschlossen werden. Dazu
zählen z.B. Untersuchungen zur Beschreibung von Zugriffsschutzmodellen im Sinne der
„sicheren“ (erlaubten) Handhabung von Informationen (das Gebiet Informationssicherheit
vertritt der Antragsteller u.a. an der HTW Dresden).
7 Fortschreibung des Konzepts der Erfolgskontrolle
12
Die im Projektantrag in vier Punkten beschriebenen Ziele zum Konzept der Erfolgskontrolle
sind erfüllt worden. Die theoretischen Grundlagen wurden erarbeitet (z.T. aus Quellen
zusammengestellt), Algorithmen zur Klassifikation wurden erarbeitet und sind im
Klassifikator umgesetzt worden. Die wissenschaftlich in der Modellierung/Programmierung
unterschiedenen Beschreibungsebenen (Mo – M3) sind dargestellt und als Basis für die
Realisierung von Ontologien verwendet worden. Die erarbeiteten Erkenntnisse wurden an
Beispiel-Implementierungen erprobt.
Die im Projektantrag definierten Meilensteine wurden gemeinsam mit dem
Kooperationspartner erfüllt (Bereitstellung eines neuen inter:gator-Clients erfolgte durch die
Interface Projects GmbH).
Die im Projekt tätigen Mitarbeiter haben die HTW Dresden nach Projektende verlassen. Einer
der Projektmitarbeiter (Herr Andre Kischkel) ist vom Projektpartner Interface Projects GmbH
übernommen worden und arbeitet in der Firma weiter an der Thematik. Der zweite
Mitarbeiter (Herr Eugen Lofing) konnte zunächst nicht weiter beschäftigt werden, ist aber an
einer Promotion (kooperatives Promotionsverfahren) auf dem Gebiet Wissensverarbeitung/
Wissenserwerb (Knowledge Mining) interessiert.
Das durch das Kooperationsprojekt gewonnene Know-how wird sowohl bei der HTW als
auch bei der Interface Projects GmbH weiter genutzt und verwertet. Unter anderem dient die
Diplomarbeit von Herrn Stephan Janosch zur Thematik des Entwurfs und der
Implementierung eines Modelleditors für abstrakte Ontologien der Fortführung der Arbeiten.
Schwerpunkt dabei ist die grafische Handhabung von Ontologien.
Weitere Arbeiten an der HTW Dresden stehen im Kontext des Kooperationsprojektes. Die
Diplomarbeit von S. Bley ist der technologischen Basis gewidmet und beschäftigt sich mit der
Modell-getriebenen Softwareentwicklung (MDSD) bei Java-basierte Software-Architekturen
[Ble08]. Auch für Herrn S. Bley wird perspektivisch ein Promotionsverfahren angestrebt.
Literaturverzeichnis
AH04 Antoniou, G.; van Harmelen, F.: A Semantic Web Primer. The MIT Press, 2004
Ble08 Bley, S.: Konzeption und Entwicklung einer Software-Factory für Java-EnterpriseAnwendungen basierend auf der Eclipse-Plattform. Diplomarbeit, HTW Dresden (FH),
2008
CNV96 Covington, M.A.; Nute, D.; Vellino, A.: Prolog Programming in Depth, 1996
DOMW3C Document Object Model (DOM) Hompage beim W3C.
http://www.w3.org/DOM/
Dyb87 Dybvig, K.R.: The Scheme Programming Language. Prentice-Hall, 1987
Fle02 Fleming, D.: Repräsentation inhaltlicher Verwandtschaftsbeziehungen von
Textdokumenten auf der Grundlage von Kohonen-Karten, Diplomarbeit, HTW Dresden
(FH), 2002
FKL07 Fritzsche, H; Kischkel, A.; Lofing, E.: Entwicklungsmethodik, Ontologieentwurf und
Wissensrepräsentation für ein domänen-unabhängiges Recherchewerkzeug unter
Einbeziehung der Semantik von Recherchekontexten, Pflichtenheft. HTW Dresden, 2007
FL08 Fritzsche, H; Lofing, E.: Jamus-Scheme: An Implementation of a Scheme subset
conform to the Revised4-5 Report on the Algorithmic Language Scheme. Technischer
Report, HTW Dresden (FH), 2008
13
Fri94 Fritzsche, H.: Architektur und Entwicklung einer hybriden Softwareentwicklungsumgebung. Habilitationsschrift, Fakultät Informatik, TU Dresden, 1994
FM00 Fritzsche, H.; Michel, T.: Formalization and proof of design guidelines within the
scope of testing formally specified electronic product catalogues. Interacting with
Computers 12 (2000), 209 - 223
Gnü08 Gnüchtel, C.: Evaluierung und Entwicklung von Softwarekomponenten in einem
Prozess zur IT-gestützten Analyse und Bewertung von textuellen Inhalten aus dem
Umfeld der elektronischen Medien. Diplomarbeit, HTW Dresden (FH), 2008.
G+05 James Gosling, Bill Joy, Guy Steele, Gilad Bracha: The Java Language Specification.
Third Edition. Addison-Wesley 2005, ISBN 0-321-24678-0
Hel01 Helbig, H.: Die semantische Struktur natürlicher Sprache. Wissensrepräsentation mit
MultiNet. Springer, Heidelberg 2001
Her02 Hermsdorf, K.: Inhaltliche Verwandtschaftsbeziehungen von Textdokumenten auf
Grundlage selbstorganisierender Karten. Diplomarbeit, HTW Dresden, 2002.
Hod01 Wilfrid Hodges: 2001, "Classical Logic I: First Order Logic," in Lou Goble, ed., The
Blackwell Guide to Philosophical Logic. Blackwell.
Hof04 Hofmann, M.: Suche von inhaltlich ähnlichen textuellen Dokumenten auf Basis von
Jakarta-Lucene unter Verwendung ausschließlich freier Bibliotheken. Diplomarbeit,
HTW Dresden, 2004.
Jena Jena – A Semantic Web Framework for Java. http://jena.sourceforge.net/
Koe03 Köhler, S.: Visualisierung von Wissensmodellen auf der Grundlage des Oracle
Internet File Systems. Diplomarbeit, HTW Dresden (FH), 2003.
KB07 Kutschera/Breitkopf, Einführung in die moderne Logik, 8. Aufl. (2007), ISBN 978-3495-482711
LF08 Lofing, E, Fritzsche, H;.: Werkzeuge zur Erstellung und Nutzung von
Kontextsemantiken. Programmdokumentation, HTW Dresden, 2008
Lor02 Lorenz, J.: Untersuchungen zur Implementation und Einbindung von Komponenten
eines Content Management Systemes, basierend auf dem Oracle iFS (Internet File
System). Diplomarbeit, HTW Dresden (FH), 2002
LUCENE Apache Lucene, http://jakarta.apache.org/lucene
OWL04 M. K. Smith, C. Welty, D. L. McGuinnes: OWL Web Ontology Language Guide.
W3C Recommendation, 10. Febr. 2004, http:/www.w3.org/TR/owl-guide
R3RS Jonathan Rees and William Clinger, editors. The revised3 report on the algorithmic
language Scheme. In ACM SIGPLAN Notices 21(12), pages 37-79, December 1986.
RDF06 Resource Description Framework (RDF) Model and Syntax. www.w3.org/TR/WDrdf-syntax-971002
RDFW3C Resource Description Framework (RDF) Homepage beim W3C.
www.w3.org/RDF/
SAX Simple API for XML (SAX) Homepage. http://www.saxproject.org/
SH89 P. Schnupp, K. Höß: TerminalBuch Prolog. Oldenbourg-Verlag, 1989
Ws07 E. Wagner, P. Schnupp: Eine Kontext-Semantik-Umgebung für den praktischen
Einsatz. Projektbericht, 2007
Som07 Sommerville, J.: Software Engineering, Addison-Wesley, München, 2007
Ste04 Stephan, A.:Untersuchungen zur grafischen Visualisierung der Beziehungen von
Akteuren eines Wissensnetzwerkes und prototypische Umsetzung. Diplomarbeit, HTW
Dresden (FH), 2004.
14
Sto88 Stoyan, H.: Programmiermethoden der Künstlichen Intelligenz, Band 1. SpringerVerlag, 1988
Tan90 Tanimoto, S.L.: KI – Die Grundlagen. Oldenbourg-Verlag, München, Wien, 1990
Wie03 Wielemaker, J. et al.: SWI-Prolog and the Web. University Amsterdam, January 2003
15